From 376d8b3d1e69e485015b2fe1e9ae48950e42e87f Mon Sep 17 00:00:00 2001
From: elexis <elexis@wildfiregames.com>
Date: Sun, 15 Oct 2017 17:53:12 +0000
Subject: [PATCH] Cleanup most createArea and some createObjectGroup calls in
 random map scripts.

Inline the placer, terrainPainter, elevationPainter, group and sizes
helper variables that are used only once.
Thus do not hoist variable declarations from unrelated scopes.
Remove few dozens of painters that are overpainted by the
paintBasedOnTerrainHeight call afterwards.
Remove 334 noisy misaligned code comments (// terrains // widths //
blend radius and // some variation).
Label the createArea calls so that the reader knows what they do.
Remove unbenefitial Math.PI/8 grass min/max angle limitation.
Use height variables for the SmoothElevationPainter calls so that levels
can be modified more easily.
Use Math prototype functions instead of the unfortunate rmgen proxies.
Does not touch starting base code, Unknown maps, Snowflake Searocks and
Corsica & Sardinia which need special treatment.

This was SVN commit r20301.
---
 .../mods/public/maps/random/aegean_sea.js     |  28 +-
 .../mods/public/maps/random/african_plains.js |  18 +-
 .../mods/public/maps/random/alpine_lakes.js   |  16 +-
 .../mods/public/maps/random/alpine_valley.js  | 161 ++++-----
 .../public/maps/random/anatolian_plateau.js   |  51 +--
 .../mods/public/maps/random/archipelago.js    |  29 +-
 .../public/maps/random/ardennes_forest.js     | 226 +++++--------
 .../public/maps/random/atlas_mountains.js     |  22 +-
 .../maps/random/cantabrian_highlands.js       |  22 +-
 .../data/mods/public/maps/random/canyon.js    | 227 ++++++-------
 .../data/mods/public/maps/random/continent.js |  40 +--
 .../public/maps/random/corinthian_isthmus.js  |   5 +-
 .../maps/random/cycladic_archipelago.js       |  99 +++---
 .../public/maps/random/english_channel.js     |  90 +++--
 .../public/maps/random/extinct_volcano.js     |   4 +-
 .../data/mods/public/maps/random/flood.js     | 308 +++++++++---------
 .../data/mods/public/maps/random/fortress.js  |  58 ++--
 binaries/data/mods/public/maps/random/gear.js | 175 ++++------
 .../public/maps/random/guadalquivir_river.js  |   5 +-
 .../public/maps/random/gulf_of_bothnia.js     | 160 +++------
 .../data/mods/public/maps/random/harbor.js    |   4 +-
 .../public/maps/random/hyrcanian_shores.js    | 146 +++------
 .../public/maps/random/island_stronghold.js   | 164 ++++------
 .../data/mods/public/maps/random/islands.js   | 171 +++++-----
 .../data/mods/public/maps/random/kerala.js    | 139 ++++----
 binaries/data/mods/public/maps/random/lake.js |  59 ++--
 .../mods/public/maps/random/lorraine_plain.js | 227 ++++++-------
 .../data/mods/public/maps/random/mainland.js  |   3 +-
 .../data/mods/public/maps/random/migration.js | 174 +++++-----
 .../maps/random/neareastern_badlands.js       | 140 ++++----
 .../public/maps/random/northern_lights.js     | 185 +++++------
 .../data/mods/public/maps/random/oasis.js     | 159 +++++----
 .../public/maps/random/persian_highlands.js   | 139 ++++----
 .../public/maps/random/phoenician_levant.js   | 131 +++-----
 .../data/mods/public/maps/random/polar_sea.js |  85 ++---
 .../public/maps/random/pyrenean_sierra.js     |  86 +++--
 .../public/maps/random/rhine_marshlands.js    | 156 ++++-----
 .../public/maps/random/river_archipelago.js   |  10 +-
 .../data/mods/public/maps/random/rivers.js    |  56 ++--
 .../public/maps/random/rmbiome/randombiome.js |   2 +-
 .../mods/public/maps/random/rmgen2/gaia.js    |  79 +++--
 .../mods/public/maps/random/saharan_oases.js  |  76 ++---
 .../data/mods/public/maps/random/sahel.js     |  50 +--
 .../maps/random/sahel_watering_holes.js       | 167 +++++-----
 .../mods/public/maps/random/schwarzwald.js    |  15 +-
 .../public/maps/random/snowflake_searocks.js  |  78 ++---
 .../maps/random/survivalofthefittest.js       |   5 +
 .../data/mods/public/maps/random/syria.js     | 121 +++----
 .../data/mods/public/maps/random/the_nile.js  | 154 ++++-----
 .../mods/public/maps/random/volcanic_lands.js | 113 +++----
 50 files changed, 2117 insertions(+), 2721 deletions(-)

diff --git a/binaries/data/mods/public/maps/random/aegean_sea.js b/binaries/data/mods/public/maps/random/aegean_sea.js
index 3df0c0393b..90b2fada16 100644
--- a/binaries/data/mods/public/maps/random/aegean_sea.js
+++ b/binaries/data/mods/public/maps/random/aegean_sea.js
@@ -210,25 +210,24 @@ createLayeredPatches(
 RMS.SetProgress(60);
 
 log("Creating undersea bumps...");
-placer = new ChainPlacer(1, floor(scaleByMapSize(4, 6)), floor(scaleByMapSize(16, 40)), 0.5);
-painter = new SmoothElevationPainter(ELEVATION_SET, -2.5, 3);
 createAreas(
-	placer,
-	[painter, paintClass(clCorals)],
+	new ChainPlacer(1, Math.floor(scaleByMapSize(4, 6)), Math.floor(scaleByMapSize(16, 40)), 0.5),
+	[
+		new SmoothElevationPainter(ELEVATION_SET, -2.5, 3),
+		paintClass(clCorals)
+	],
 	stayClasses(clWater, 6),
 	scaleByMapSize(10, 50)
 );
 
 log("Creating islands...");
-placer = new ChainPlacer(1, floor(scaleByMapSize(4, 6)), floor(scaleByMapSize(30, 80)), 0.5);
-var terrainPainter = new LayeredPainter(
-	[tWater, tShore, tHill],		// terrains
-	[2 ,1]								// widths
-);
-var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 6, 4);
 createAreas(
-	placer,
-	[terrainPainter, elevationPainter, paintClass(clIsland)],
+	new ChainPlacer(1, Math.floor(scaleByMapSize(4, 6)), Math.floor(scaleByMapSize(30, 80)), 0.5),
+	[
+		new LayeredPainter([tWater, tShore, tHill], [2 ,1]),
+		new SmoothElevationPainter(ELEVATION_SET, 6, 4),
+		paintClass(clIsland)
+	],
 	[avoidClasses(clPlayer, 8, clForest, 1, clIsland, 15), stayClasses (clWater, 6)],
 	scaleByMapSize(1, 4) * numPlayers
 );
@@ -328,8 +327,9 @@ createFood
 
 RMS.SetProgress(90);
 
-var types = [oDatePalm, oSDatePalm, oCarob, oFanPalm, oPoplar, oCypress];	// some variation
-createStragglerTrees(types, avoidClasses(clForest, 1, clWater, 2, clPlayer, 12, clMetal, 6, clHill, 1));
+createStragglerTrees(
+	[oDatePalm, oSDatePalm, oCarob, oFanPalm, oPoplar, oCypress],
+	avoidClasses(clForest, 1, clWater, 2, clPlayer, 12, clMetal, 6, clHill, 1));
 
 log("Creating straggler island trees...");
 g_numStragglerTrees *= 10;
diff --git a/binaries/data/mods/public/maps/random/african_plains.js b/binaries/data/mods/public/maps/random/african_plains.js
index 1b5bf625c0..8df3aef358 100644
--- a/binaries/data/mods/public/maps/random/african_plains.js
+++ b/binaries/data/mods/public/maps/random/african_plains.js
@@ -139,15 +139,13 @@ for (var x = 0; x < mapSize; ++x)
 			lakeAreas.push([x, z]);
 
 log("Creating water holes...");
-placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), floor(scaleByMapSize(60, 100)), 5);
-var terrainPainter = new LayeredPainter(
-	[tShore, tWater],		// terrains
-	[1]							// widths
-);
-var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -5, 7);
 createAreas(
-	placer,
-	[terrainPainter, elevationPainter, paintClass(clWater)],
+	new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), Math.floor(scaleByMapSize(60, 100)), 5),
+	[
+		new LayeredPainter([tShore, tWater], [1]),
+		new SmoothElevationPainter(ELEVATION_SET, -5, 7),
+		paintClass(clWater)
+	],
 	avoidClasses(clPlayer, 22, clWater, 8, clHill, 2),
 	scaleByMapSize(2, 5)
 );
@@ -214,14 +212,14 @@ createDecoration(
 	],
 	[
 		scaleByMapSize(8, 131),
-		scaleByMapSize(8, 131),
+		scaleByMapSize(8, 131)
 	],
 	avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0)
 );
 RMS.SetProgress(75);
 
 log("Creating giraffes...");
-group = new SimpleGroup(
+var group = new SimpleGroup(
 	[new SimpleObject(oGiraffe, 2,4, 0,4), new SimpleObject(oGiraffe2, 0,2, 0,4)],
 	true, clFood
 );
diff --git a/binaries/data/mods/public/maps/random/alpine_lakes.js b/binaries/data/mods/public/maps/random/alpine_lakes.js
index d8dd2a8747..cc030dd66f 100644
--- a/binaries/data/mods/public/maps/random/alpine_lakes.js
+++ b/binaries/data/mods/public/maps/random/alpine_lakes.js
@@ -207,15 +207,13 @@ for (var i = 0; i < numLakes; ++i)
 
 	let chosenPoint = pickRandom(lakeAreas);
 
-	placer = new ChainPlacer(1, floor(scaleByMapSize(4, 8)), floor(scaleByMapSize(40, 180)), 0.7, chosenPoint[0], chosenPoint[1]);
-	var terrainPainter = new LayeredPainter(
-		[tShore, tWater, tWater],		// terrains
-		[1, 3]								// widths
-	);
-	var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -5, 5);
-	var newLake = createAreas(
-		placer,
-		[terrainPainter, elevationPainter, paintClass(clWater)],
+	let newLake = createAreas(
+		new ChainPlacer(1, Math.floor(scaleByMapSize(4, 8)), Math.floor(scaleByMapSize(40, 180)), 0.7, chosenPoint[0], chosenPoint[1]),
+		[
+			new LayeredPainter([tShore, tWater, tWater], [1, 3]),
+			new SmoothElevationPainter(ELEVATION_SET, -5, 5),
+			paintClass(clWater)
+		],
 		avoidClasses(clPlayer, 20, clWater, 8),
 		1, 1
 	);
diff --git a/binaries/data/mods/public/maps/random/alpine_valley.js b/binaries/data/mods/public/maps/random/alpine_valley.js
index fba0b495e2..0b53221aae 100644
--- a/binaries/data/mods/public/maps/random/alpine_valley.js
+++ b/binaries/data/mods/public/maps/random/alpine_valley.js
@@ -98,7 +98,7 @@ for (var i = 0; i < numPlayers; i++)
 
 	// create the city patch
 	var cityRadius = radius/3;
-	placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
+	var placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tRoadWild, tRoad], [1]);
 	createArea(placer, painter, null);
 
@@ -234,10 +234,14 @@ while (possibleEdges.length)
 
 	matrix[possibleEdges[index][0]][possibleEdges[index][1]] = true;
 	matrix[possibleEdges[index][1]][possibleEdges[index][0]] = true;
-	var selected, accept = true, tree = [], backtree = [];
+
+	let accept = true;
+	let tree = [];
+	let backtree = [];
+
 	while (q.length > 0)
 	{
-		selected = q.shift();
+		let selected = q.shift();
 		if (tree.indexOf(selected) == -1)
 		{
 			tree.push(selected);
@@ -276,17 +280,14 @@ while (possibleEdges.length)
 	var iz = points[possibleEdges[index][0]][1];
 	var ix2 = points[possibleEdges[index][1]][0];
 	var iz2 = points[possibleEdges[index][1]][1];
-	var placer = new PathPlacer(ix, iz, ix2, iz2, scaleByMapSize(9,15), 0.4, 3*(scaleByMapSize(1,4)), 0.1, 0.1, 0.1);
-	var terrainPainter = new LayeredPainter(
-		[tCliff, tPrimary],		// terrains
-		[3]		// widths
-	);
-	var elevationPainter = new SmoothElevationPainter(
-		ELEVATION_SET,			// type
-		30,				// elevation
-		2				// blend radius
-	);
-	accept = createArea(placer, [terrainPainter, elevationPainter, paintClass(clHill)], avoidClasses(clPlayer, 20));
+	accept = createArea(
+		new PathPlacer(ix, iz, ix2, iz2, scaleByMapSize(9,15), 0.4, 3 * scaleByMapSize(1, 4), 0.1, 0.1, 0.1),
+		[
+			new LayeredPainter([tCliff, tPrimary], [3]),
+			new SmoothElevationPainter(ELEVATION_SET, 30, 2),
+			paintClass(clHill)
+		],
+		avoidClasses(clPlayer, 20));
 
 	if (accept == null)
 	{
@@ -295,32 +296,16 @@ while (possibleEdges.length)
 		possibleEdges.splice(index,1);
 		continue;
 	}
-	else
-	{
-		placer = new ClumpPlacer(floor(PI*scaleByMapSize(9,15)*scaleByMapSize(9,15)/4), 0.95, 0.6, 10, ix, iz);
-		var terrainPainter = new LayeredPainter(
-			[tCliff, tPrimary],		// terrains
-			[3]		// widths
-		);
-		var elevationPainter = new SmoothElevationPainter(
-			ELEVATION_SET,			// type
-			30,				// elevation
-			2				// blend radius
-		);
-		createArea(placer, [terrainPainter, elevationPainter, paintClass(clHill)], avoidClasses(clPlayer, 5));
 
-		placer = new ClumpPlacer(floor(PI*scaleByMapSize(9,15)*scaleByMapSize(9,15)/4), 0.95, 0.6, 10, ix2, iz2);
-		var terrainPainter = new LayeredPainter(
-			[tCliff, tPrimary],		// terrains
-			[3]		// widths
-		);
-		var elevationPainter = new SmoothElevationPainter(
-			ELEVATION_SET,			// type
-			30,				// elevation
-			2				// blend radius
-		);
-		createArea(placer, [terrainPainter, elevationPainter, paintClass(clHill)], avoidClasses(clPlayer, 5));
-	}
+	for (let [x, z] of [[ix, iz], [ix2, iz2]])
+		createArea(
+			new ClumpPlacer(Math.floor(Math.PI * Math.pow(scaleByMapSize(9, 15) / 2, 2)), 0.95, 0.6, 10, x, z),
+			[
+				new LayeredPainter([tCliff, tPrimary], [3]),
+				new SmoothElevationPainter(ELEVATION_SET, 30, 2),
+				paintClass(clHill)
+			],
+			avoidClasses(clPlayer, 5));
 
 	for (var i = 0; i < possibleEdges.length; ++i)
 	{
@@ -373,26 +358,21 @@ paintTerrainBasedOnHeight(3.1, 29, 0, tCliff);
 paintTerrainBasedOnHeight(29, 30, 3, tSnowLimited);
 
 log("Creating bumps...");
-placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1);
-painter = new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2);
 createAreas(
-	placer,
-	painter,
+	new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1),
+	new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2),
 	avoidClasses(clPlayer, 10),
-	scaleByMapSize(100, 200)
-);
+	scaleByMapSize(100, 200));
 RMS.SetProgress(40);
 
 log("Creating hills...");
-placer = new ClumpPlacer(scaleByMapSize(40, 150), 0.2, 0.1, 1);
-var terrainPainter = new LayeredPainter(
-	[tCliff, tSnowLimited],		// terrains
-	[2]								// widths
-);
-var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 30, 2);
 createAreas(
-	placer,
-	[terrainPainter, elevationPainter, paintClass(clHill)],
+	new ClumpPlacer(scaleByMapSize(40, 150), 0.2, 0.1, 1),
+	[
+		new LayeredPainter([tCliff, tSnowLimited], [2]),
+		new SmoothElevationPainter(ELEVATION_SET, 30, 2),
+		paintClass(clHill)
+	],
 	avoidClasses(clPlayer, 20, clHill, 14),
 	scaleByMapSize(10, 80) * numPlayers
 );
@@ -410,57 +390,41 @@ var numStragglers = totalTrees * (1.0 - P_FOREST);
 log("Creating forests...");
 var types = [
 	[[tForestFloor, tPrimary, pForest], [tForestFloor, pForest]]
-];	// some variation
+];
 
 var size = numForest / (scaleByMapSize(2,8) * numPlayers);
 
-var num = floor(size / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	placer = new ClumpPlacer(numForest / num, 0.1, 0.1, 1);
-	painter = new LayeredPainter(
-		types[i],		// terrains
-		[2]											// widths
-		);
+var num = Math.floor(size / types.length);
+for (let type of types)
 	createAreas(
-		placer,
-		[painter, paintClass(clForest)],
+		new ClumpPlacer(numForest / num, 0.1, 0.1, 1),
+		[
+			new LayeredPainter(type, [2]),
+			paintClass(clForest)
+		],
 		avoidClasses(clPlayer, 12, clForest, 10, clHill, 0),
-		num
-	);
-}
+		num);
 RMS.SetProgress(60);
 
 log("Creating dirt patches...");
-var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
-for (var i = 0; i < sizes.length; i++)
-{
-	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
-	painter = new LayeredPainter(
-		[[tDirt,tHalfSnow], [tHalfSnow,tSnowLimited]], 		// terrains
-		[2]															// widths
-	);
+for (let size of [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)])
 	createAreas(
-		placer,
-		[painter, paintClass(clDirt)],
+		new ClumpPlacer(size, 0.3, 0.06, 0.5),
+		[
+			new LayeredPainter([[tDirt, tHalfSnow], [tHalfSnow, tSnowLimited]], [2]),
+			paintClass(clDirt)
+		],
 		avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12),
-		scaleByMapSize(15, 45)
-	);
-}
+		scaleByMapSize(15, 45));
 
 log("Creating grass patches...");
-var sizes = [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)];
-for (var i = 0; i < sizes.length; i++)
-{
-	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
-	painter = new TerrainPainter(tSecondary);
+for (let size of [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)])
 	createAreas(
-		placer,
-		painter,
+		new ClumpPlacer(size, 0.3, 0.06, 0.5),
+		new TerrainPainter(tSecondary),
 		avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12),
-		scaleByMapSize(15, 45)
-	);
-}
+		scaleByMapSize(15, 45));
+
 RMS.SetProgress(65);
 
 log("Creating stone mines...");
@@ -540,19 +504,14 @@ createObjectGroupsDeprecated(group, 0,
 RMS.SetProgress(85);
 
 log("Creating straggler trees...");
-var types = [oPine, oPine];	// some variation
+var types = [oPine, oPine];
 var num = floor(numStragglers / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	group = new SimpleGroup(
-		[new SimpleObject(types[i], 1,1, 0,3)],
-		true, clForest
-	);
-	createObjectGroupsDeprecated(group, 0,
+for (let type of types)
+	createObjectGroupsDeprecated(
+		new SimpleGroup([new SimpleObject(type, 1,1, 0,3)], true, clForest),
+		0,
 		avoidClasses(clForest, 1, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6),
-		num
-	);
-}
+		num);
 
 log("Creating small grass tufts...");
 var planetm = 1;
diff --git a/binaries/data/mods/public/maps/random/anatolian_plateau.js b/binaries/data/mods/public/maps/random/anatolian_plateau.js
index ffb556d953..2631b9979b 100644
--- a/binaries/data/mods/public/maps/random/anatolian_plateau.js
+++ b/binaries/data/mods/public/maps/random/anatolian_plateau.js
@@ -123,17 +123,13 @@ for (var i = 0; i < numPlayers; i++)
 RMS.SetProgress(20);
 
 log("Creating bumps...");
-placer = new ChainPlacer(1, floor(scaleByMapSize(4, 6)), floor(scaleByMapSize(2, 5)), 0.5);
-painter = new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2);
 createAreas(
-	placer,
-	painter,
+	new ChainPlacer(1, Math.floor(scaleByMapSize(4, 6)), Math.floor(scaleByMapSize(2, 5)), 0.5),
+	new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2),
 	avoidClasses(clPlayer, 13),
-	scaleByMapSize(300, 800)
-);
+	scaleByMapSize(300, 800));
 
 // calculate desired number of trees for map (based on size)
-
 var MIN_TREES = 220;
 var MAX_TREES = 1000;
 var P_FOREST = 0.65;
@@ -143,26 +139,18 @@ var numForest = totalTrees * P_FOREST;
 var numStragglers = totalTrees * (1.0 - P_FOREST);
 
 log("Creating forests...");
-var types = [[[tForestFloor, tGrass, pForest], [tForestFloor, pForest]]];	// some variation
-
+var types = [[[tForestFloor, tGrass, pForest], [tForestFloor, pForest]]];
 var size = numForest / (scaleByMapSize(2,8) * numPlayers);
-
 var num = 4 * floor(size / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	placer = new ChainPlacer(1, floor(scaleByMapSize(2, 3)), 4, 1);
-	painter = new LayeredPainter(
-		types[i],		// terrains
-		[2]											// widths
-		);
+for (let type of types)
 	createAreas(
-		placer,
-		[painter, paintClass(clForest)],
+		new ChainPlacer(1, Math.floor(scaleByMapSize(2, 3)), 4, 1),
+		[
+			new LayeredPainter(type, [2]),
+			paintClass(clForest)
+		],
 		avoidClasses(clPlayer, 13, clForest, 20, clHill, 1),
-		num
-	);
-}
-
+		num);
 RMS.SetProgress(50);
 
 log("Creating grass patches...");
@@ -281,19 +269,14 @@ createObjectGroupsDeprecated(group, 0,
 RMS.SetProgress(85);
 
 log("Creating straggler trees...");
-var types = [oBush, oPoplar];	// some variation
+var types = [oBush, oPoplar];
 var num = floor(numStragglers / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	group = new SimpleGroup(
-		[new SimpleObject(types[i], 1,1, 0,3)],
-		true, clForest
-	);
-	createObjectGroupsDeprecated(group, 0,
+for (let type of types)
+	createObjectGroupsDeprecated(
+		new SimpleGroup([new SimpleObject(type, 1, 1, 0, 3)], true, clForest),
+		0,
 		avoidClasses(clForest, 1, clHill, 1, clPlayer, 13, clMetal, 6, clRock, 6),
-		num
-	);
-}
+		num);
 
 log("Creating large grass tufts...");
 group = new SimpleGroup(
diff --git a/binaries/data/mods/public/maps/random/archipelago.js b/binaries/data/mods/public/maps/random/archipelago.js
index c6154dba4f..617240af69 100644
--- a/binaries/data/mods/public/maps/random/archipelago.js
+++ b/binaries/data/mods/public/maps/random/archipelago.js
@@ -154,18 +154,21 @@ for (var i = 0; i < numPlayers; i++)
 }
 
 log("Creating islands...");
-placer = new ChainPlacer(floor(scaleByMapSize(4, 8)), floor(scaleByMapSize(8, 14)), floor(scaleByMapSize(25, 60)), 0.07, undefined, undefined, scaleByMapSize(30,70));
-terrainPainter = new LayeredPainter(
-	[tMainTerrain, tMainTerrain],		// terrains
-	[2]								// widths
-);
-elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 4);
 createAreas(
-	placer,
-	[terrainPainter, elevationPainter, paintClass(clLand)],
+	new ChainPlacer(
+		Math.floor(scaleByMapSize(4, 8)),
+		Math.floor(scaleByMapSize(8, 14)),
+		Math.floor(scaleByMapSize(25, 60)),
+		0.07,
+		undefined,
+		undefined,
+		scaleByMapSize(30, 70)),
+	[
+		new SmoothElevationPainter(ELEVATION_SET, 3, 4),
+		paintClass(clLand)
+	],
 	null,
-	scaleByMapSize(1, 5) * randIntInclusive(5, 10)
-);
+	scaleByMapSize(1, 5) * randIntInclusive(5, 10));
 
 paintTerrainBasedOnHeight(2.4, 3.4, 3, tMainTerrain);
 paintTerrainBasedOnHeight(1, 3, 0, tShore);
@@ -299,8 +302,10 @@ createFood
 RMS.SetProgress(85);
 
 log("Creating straggler trees...");
-var types = [oTree1, oTree2, oTree4, oTree3];	// some variation
-createStragglerTrees(types, [avoidClasses(clForest, 7, clHill, 1, clPlayer, 3, clMetal, 6, clRock, 6), stayClasses(clLand, 7)]);
+createStragglerTrees(
+	[oTree1, oTree2, oTree4, oTree3],
+	[avoidClasses(clForest, 7, clHill, 1, clPlayer, 3, clMetal, 6, clRock, 6), stayClasses(clLand, 7)]);
+
 setWaterWaviness(4.0);
 setWaterType("ocean");
 
diff --git a/binaries/data/mods/public/maps/random/ardennes_forest.js b/binaries/data/mods/public/maps/random/ardennes_forest.js
index e950e9c5b8..e808ae6d79 100644
--- a/binaries/data/mods/public/maps/random/ardennes_forest.js
+++ b/binaries/data/mods/public/maps/random/ardennes_forest.js
@@ -62,22 +62,13 @@ var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clHillDeco = createTileClass();
 
-// Create central dip
-var centerX = fractionToTiles(0.5);
-var centerZ = fractionToTiles(0.5);
-
-var placer = new ClumpPlacer(scaleByMapSize(mapSize * 70, mapSize * 300), 0.94, 0.05, 0.1, centerX, centerZ);
-var elevationPainter = new SmoothElevationPainter(
-	    ELEVATION_SET,
-	    30,
-	    3
-    );
-var painter = new LayeredPainter(
-		[tCliff, tGrass],		// terrains
-		[3]		// widths
-	);
-createArea(placer,
-	[painter, elevationPainter],
+log("Creating the central dip...");
+createArea(
+	new ClumpPlacer(mapSize * scaleByMapSize(70, 300), 0.94, 0.05, 0.1, fractionToTiles(0.5), fractionToTiles(0.5)),
+	[
+		new LayeredPainter([tCliff, tGrass], [3]),
+		new SmoothElevationPainter(ELEVATION_SET, 30, 3)
+	],
 	null);
 
 RMS.SetProgress(5);
@@ -207,134 +198,87 @@ for (var i=0; i < numPlayers; i++)
 RMS.SetProgress(30);
 
 log("Creating hills...");
-var sizes = [scaleByMapSize(50, 800), scaleByMapSize(50, 400), scaleByMapSize(10, 30), scaleByMapSize(10, 30)];
-for (var i = 0; i < sizes.length; i++)
+for (let size of [scaleByMapSize(50, 800), scaleByMapSize(50, 400), scaleByMapSize(10, 30), scaleByMapSize(10, 30)])
 {
-	var placer = new ClumpPlacer(sizes[i], 0.1, 0.2, 0.1);
-	var painter = new LayeredPainter(
-		[tCliff, [tForestFloor, tForestFloor, tCliff]],		// terrains
-		[2]		// widths
-	);
-	var elevationPainter = new SmoothElevationPainter(
-	    ELEVATION_SET,
-	    50,
-	    sizes[i] < 50 ? 2 : 4
-    );
-
-	var mountains = createAreas(
-		placer,
-		[painter, paintClass(clHill), elevationPainter],
+	let mountains = createAreas(
+		new ClumpPlacer(size, 0.1, 0.2, 0.1),
+		[
+			new LayeredPainter([tCliff, [tForestFloor, tForestFloor, tCliff]], [2]),
+			new SmoothElevationPainter(ELEVATION_SET, 50, size < 50 ? 2 : 4),
+			paintClass(clHill)
+		],
 		avoidClasses(clPlayer, 8, clBaseResource, 2, clHill, 5),
-		scaleByMapSize(1, 4)
-	);
-
-	if(sizes[i] > 100 && mountains.length > 0)
-	{
-		var placer = new ClumpPlacer(sizes[i] * 0.3, 0.94, 0.05, 0.1);
-		var elevationPainter = new SmoothElevationPainter(
-				 ELEVATION_MODIFY,
-				 10,
-				 3
-			 );
-		var painter = new LayeredPainter(
-			[tCliff, tForestFloor],		// terrains
-			[2]		// widths
-		);
+		scaleByMapSize(1, 4));
 
+	if (size > 100 && mountains.length)
 		createAreasInAreas(
-			placer,
-			[painter, elevationPainter],
+			new ClumpPlacer(size * 0.3, 0.94, 0.05, 0.1),
+			[
+				new LayeredPainter([tCliff, tForestFloor], [2]),
+				new SmoothElevationPainter(ELEVATION_MODIFY, 10, 3)
+			],
 			stayClasses(clHill, 4),
 			mountains.length * 2,
 			20,
-			mountains
-		);
-	}
+			mountains);
 
-	var placer = new ClumpPlacer(sizes[i], 0.1, 0.2, 0.1);
-
-	var elevationPainter = new SmoothElevationPainter(
-	    ELEVATION_SET,
-	    10,
-	    2
-    );
-
-	var ravine = createAreas(
-		placer,
-		[painter, paintClass(clHill), elevationPainter],
-		avoidClasses(clPlayer, 6, clBaseResource, 2, clHill, 5),
-		scaleByMapSize(1, 3)
-	);
-
-	if(sizes[i] > 150 && ravine.length > 0)
-	{
-		// Place huts in ravines
-		var group = new RandomGroup(
+	let ravine = createAreas(
+		new ClumpPlacer(size, 0.1, 0.2, 0.1),
 		[
-			new SimpleObject(aCeltHouse, 0,1, 4,5),
-			new SimpleObject(aCeltLongHouse, 1,1, 4,5)
-		], true, clHillDeco);
+			painter,
+			paintClass(clHill),
+			new SmoothElevationPainter(ELEVATION_SET, 10, 2)
+		],
+		avoidClasses(clPlayer, 6, clBaseResource, 2, clHill, 5),
+		scaleByMapSize(1, 3));
+
+	if (size > 150 && ravine.length)
+	{
+		log("Placing huts in ravines...");
 		createObjectGroupsByAreasDeprecated(
-			group, 0,
+			new RandomGroup(
+				[
+					new SimpleObject(aCeltHouse, 0, 1, 4, 5),
+					new SimpleObject(aCeltLongHouse, 1, 1, 4, 5)
+				],
+				true,
+				clHillDeco),
+			0,
 			[avoidClasses(clHillDeco, 3), stayClasses(clHill, 3)],
 			ravine.length * 5, 20,
-			ravine
-		);
+			ravine);
 
-		var group = new RandomGroup(
-		[
-			new SimpleObject(aCeltHomestead, 1,1, 1,1)
-		], true, clHillDeco);
 		createObjectGroupsByAreasDeprecated(
-			group, 0,
+			new RandomGroup([new SimpleObject(aCeltHomestead, 1, 1, 1, 1)], true, clHillDeco),
+			0,
 			[avoidClasses(clHillDeco, 5), stayClasses(clHill, 4)],
 			ravine.length * 2, 100,
-			ravine
-		);
+			ravine);
 
 		// Place noise
-		var placer = new ClumpPlacer(sizes[i] * 0.3, 0.94, 0.05, 0.1);
-		var elevationPainter = new SmoothElevationPainter(
-				 ELEVATION_SET,
-				 2,
-				 2
-			 );
-		var painter = new LayeredPainter(
-			[tCliff, tForestFloor],		// terrains
-			[2]		// widths
-		);
-
 		createAreasInAreas(
-			placer,
-			[painter, elevationPainter],
+			new ClumpPlacer(size * 0.3, 0.94, 0.05, 0.1),
+			[
+				new LayeredPainter([tCliff, tForestFloor], [2]),
+				new SmoothElevationPainter(ELEVATION_SET, 2, 2)
+			],
 			[avoidClasses(clHillDeco, 2), stayClasses(clHill, 0)],
 			ravine.length * 2,
 			20,
-			ravine
-		);
-
-		var placer = new ClumpPlacer(sizes[i] * 0.1, 0.3, 0.05, 0.1);
-		var elevationPainter = new SmoothElevationPainter(
-				 ELEVATION_SET,
-				 40,
-				 2
-			 );
-		var painter = new LayeredPainter(
-			[tCliff, tForestFloor],		// terrains
-			[2]		// widths
-		);
+			ravine);
 
 		createAreasInAreas(
-			placer,
-			[painter, paintClass(clHill), elevationPainter],
+			new ClumpPlacer(size * 0.1, 0.3, 0.05, 0.1),
+			[
+				new LayeredPainter([tCliff, tForestFloor], [2]),
+				new SmoothElevationPainter(ELEVATION_SET, 40, 2),
+				paintClass(clHill)
+			],
 			[avoidClasses(clHillDeco, 2), borderClasses(clHill, 15, 1)],
 			ravine.length * 2,
 			50,
-			ravine
-		);
+			ravine);
 	}
-
-	RMS.SetProgress(30 + (20 * (i / sizes.length)));
 }
 
 RMS.SetProgress(50);
@@ -423,35 +367,21 @@ createAreasInAreas(
 RMS.SetProgress(70);
 
 log("Creating grass patches...");
-var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
-for (var i = 0; i < sizes.length; i++)
-{
-	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
-	painter = new LayeredPainter(
-		[[tGrass,tGrassPatch],[tGrassPatch,tGrass], [tGrass,tGrassPatch]], 		// terrains
-		[1,1]															// widths
-	);
+for (let size of [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)])
 	createAreas(
-		placer,
-		painter,
+		new ClumpPlacer(size, 0.3, 0.06, 0.5),
+		new LayeredPainter([[tGrass, tGrassPatch], [tGrassPatch, tGrass], [tGrass, tGrassPatch]], [1, 1]),
 		avoidClasses(clForest, 0, clHill, 2, clPlayer, 5),
-		scaleByMapSize(15, 45)
-	);
-}
+		scaleByMapSize(15, 45));
 
 log("Creating chopped forest patches...");
-var sizes = [scaleByMapSize(20, 120)];
-for (var i = 0; i < sizes.length; i++)
-{
-	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
-	painter = new TerrainPainter(tForestFloor);
+for (let size of [scaleByMapSize(20, 120)])
 	createAreas(
-		placer,
-		painter,
+		new ClumpPlacer(size, 0.3, 0.06, 0.5),
+		new TerrainPainter(tForestFloor),
 		avoidClasses(clForest, 1, clHill, 2, clPlayer, 5),
-		scaleByMapSize(4, 12)
-	);
-}
+		scaleByMapSize(4, 12));
+
 RMS.SetProgress(75);
 
 log("Creating stone mines...");
@@ -544,21 +474,15 @@ createObjectGroupsByAreasDeprecated(
 RMS.SetProgress(90);
 
 log("Creating straggler trees...");
-var types = [oOak, oOakLarge, oPine, oAleppoPine];	// some variation
+var types = [oOak, oOakLarge, oPine, oAleppoPine];
 var num = floor(numStragglers / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	group = new SimpleGroup(
-		[new SimpleObject(types[i], 1,1, 0,3)],
-		true, clForest
-	);
-
-	createObjectGroupsByAreasDeprecated(group, 0,
+for (let type of types)
+	createObjectGroupsByAreasDeprecated(
+		new SimpleGroup([new SimpleObject(type, 1, 1, 0, 3)], true, clForest),
+		0,
 		avoidClasses(clForest, 4, clHill, 5, clPlayer, 10, clBaseResource, 2, clMetal, 5, clRock, 5),
 		num, 20,
-		[explorableArea]
-	);
-}
+		[explorableArea]);
 
 RMS.SetProgress(95);
 
diff --git a/binaries/data/mods/public/maps/random/atlas_mountains.js b/binaries/data/mods/public/maps/random/atlas_mountains.js
index 99ad4299cc..dbaf4cd6a9 100644
--- a/binaries/data/mods/public/maps/random/atlas_mountains.js
+++ b/binaries/data/mods/public/maps/random/atlas_mountains.js
@@ -246,23 +246,19 @@ createObjectGroupsDeprecated(group, 0,
 
 RMS.SetProgress(80);
 
-var types = [oCarob, oAleppoPine];	// some variation
-createStragglerTrees(types, avoidClasses(clForest, 1, clHill, 1, clPlayer, 10, clMetal, 6, clRock, 6, clTreasure, 4));
+createStragglerTrees(
+	[oCarob, oAleppoPine],
+	avoidClasses(clForest, 1, clHill, 1, clPlayer, 10, clMetal, 6, clRock, 6, clTreasure, 4));
 
 log("Creating hill trees...");
-var types = [aCarob, aAleppoPine];	// some variation
+var types = [aCarob, aAleppoPine];
 var num = floor(0.2 * g_numStragglerTrees / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	group = new SimpleGroup(
-		[new SimpleObject(types[i], 1,1, 0,3)],
-		true, clForest
-	);
-	createObjectGroupsDeprecated(group, 0,
+for (let type of types)
+	createObjectGroupsDeprecated(
+		new SimpleGroup([new SimpleObject(type, 1, 1, 0, 3)], true, clForest),
+		0,
 		stayClasses(clHill, 2),
-		num
-	);
-}
+		num);
 
 setFogFactor(0.2);
 setFogThickness(0.14);
diff --git a/binaries/data/mods/public/maps/random/cantabrian_highlands.js b/binaries/data/mods/public/maps/random/cantabrian_highlands.js
index 185080e7fc..9b0b4c3e5b 100644
--- a/binaries/data/mods/public/maps/random/cantabrian_highlands.js
+++ b/binaries/data/mods/public/maps/random/cantabrian_highlands.js
@@ -165,15 +165,13 @@ RMS.SetProgress(10);
 
 log("Creating lakes...");
 var numLakes = round(scaleByMapSize(1,4) * numPlayers);
-placer = new ClumpPlacer(scaleByMapSize(100,250), 0.8, 0.1, 10);
-terrainPainter = new LayeredPainter(
-	[tShoreBlend, tShore, tWater],		// terrains
-	[1,1]							// widths
-);
-elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -7, 6);
 var waterAreas = createAreas(
-	placer,
-	[terrainPainter, elevationPainter, paintClass(clWater)],
+	new ClumpPlacer(scaleByMapSize(100, 250), 0.8, 0.1, 10),
+	[
+		new LayeredPainter([tShoreBlend, tShore, tWater], [1, 1]),
+		new SmoothElevationPainter(ELEVATION_SET, -7, 6),
+		paintClass(clWater)
+	],
 	avoidClasses(clPlayer, 2, clWater, 20),
 	numLakes
 );
@@ -301,14 +299,14 @@ createFood
 );
 RMS.SetProgress(85);
 
-log("Creating metal mines...");
-var types = [oOak, oOakLarge, oPine, oApple];	// some variation
-createStragglerTrees(types, avoidClasses(clWater, 1, clForest, 1, clHill, 1, clPlayer, 1, clMetal, 6, clRock, 6));
+createStragglerTrees(
+	[oOak, oOakLarge, oPine, oApple],
+	avoidClasses(clWater, 1, clForest, 1, clHill, 1, clPlayer, 1, clMetal, 6, clRock, 6));
 RMS.SetProgress(90);
 
 setSkySet("cirrus");
 setWaterColor(0.447, 0.412, 0.322);			// muddy brown
-setWaterTint(0.447, 0.412, 0.322);				// muddy brown
+setWaterTint(0.447, 0.412, 0.322);
 setWaterMurkiness(1.0);
 setWaterWaviness(3.0);
 setWaterType("lake");
diff --git a/binaries/data/mods/public/maps/random/canyon.js b/binaries/data/mods/public/maps/random/canyon.js
index 2e29bd47e8..0bf4cfcb50 100644
--- a/binaries/data/mods/public/maps/random/canyon.js
+++ b/binaries/data/mods/public/maps/random/canyon.js
@@ -57,27 +57,11 @@ var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clLand = createTileClass();
 
+var landHeight = 3;
+var hillHeight = 30;
+
 initTerrain(tMainTerrain);
 
-var fx = fractionToTiles(0.5);
-var fz = fractionToTiles(0.5);
-ix = round(fx);
-iz = round(fz);
-
-var lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 6))));
-
-var placer = new ClumpPlacer(mapArea * 0.065 * lSize, 0.7, 0.1, 10, ix, iz);
-var terrainPainter = new LayeredPainter(
-	[tMainTerrain, tMainTerrain],		// terrains
-	[3]		// widths
-);
-var elevationPainter = new SmoothElevationPainter(
-	ELEVATION_SET,			// type
-	3,				// elevation
-	3				// blend radius
-);
-createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
-
 var [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
@@ -169,51 +153,57 @@ for (var i = 0; i < numPlayers; i++)
 
 }
 
-placer = new ClumpPlacer(150, 0.6, 0.3, 10, fractionToTiles(0.5), fractionToTiles(0.5));
-var painter = new LayeredPainter([tRoad, tRoad], [1]);
-createArea(placer, [painter, paintClass(clHill)], null);
+log("Creating center area...");
+var center = Math.round(fractionToTiles(0.5));
+var lSize = Math.pow(scaleByMapSize(1, 6), 1/8);
 
-for (var i = 0; i < scaleByMapSize(9,16); i++)
-{
-	var placer = new PathPlacer(
-		randIntExclusive(1, mapSize),
-		randIntExclusive(1, mapSize),
-		randIntExclusive(1, mapSize),
-		randIntExclusive(1, mapSize),
-		scaleByMapSize(11,16),
-		0.4,
-		3 * scaleByMapSize(1,4),
-		0.1,
-		0);
+createArea(
+	new ClumpPlacer(mapArea * 0.065 * lSize, 0.7, 0.1, 10, center, center),
+	[
+		new LayeredPainter([tMainTerrain, tMainTerrain], [3]),
+		new SmoothElevationPainter(ELEVATION_SET, landHeight, 3),
+		paintClass(clLand)
+	],
+	null);
 
-	var terrainPainter = new LayeredPainter(
-		[tMainTerrain, tMainTerrain],		// terrains
-		[3]		// widths
-	);
-	var elevationPainter = new SmoothElevationPainter(
-		ELEVATION_SET,			// type
-		30,				// elevation
-		3				// blend radius
-	);
-	createArea(placer, [terrainPainter, elevationPainter, paintClass(clHill2)], avoidClasses(clPlayer, 6, clHill2, 3, clHill, 2));
-}
+createArea(
+	new ClumpPlacer(150, 0.6, 0.3, 10, center, center),
+	paintClass(clHill),
+	null);
 
-for (var g = 0; g < scaleByMapSize(5,30); g++)
+log("Creating hills...");
+for (let i = 0; i < scaleByMapSize(9, 16); ++i)
+	createArea(
+		new PathPlacer(
+			randIntExclusive(1, mapSize),
+			randIntExclusive(1, mapSize),
+			randIntExclusive(1, mapSize),
+			randIntExclusive(1, mapSize),
+			scaleByMapSize(11, 16),
+			0.4,
+			3 * scaleByMapSize(1, 4),
+			0.1,
+			0),
+		[
+			new SmoothElevationPainter(ELEVATION_SET, hillHeight, 3),
+			paintClass(clHill2)
+		],
+		avoidClasses(clPlayer, 6, clHill2, 3, clHill, 2));
+
+for (let g = 0; g < scaleByMapSize(5, 30); ++g)
 {
 	var tx = randIntInclusive(1, mapSize - 1);
 	var tz = randIntInclusive(1, mapSize - 1);
 
-	placer = new ClumpPlacer(mapArea * 0.01 * lSize, 0.7, 0.1, 10, tx, tz);
-	terrainPainter = new LayeredPainter(
-		[tMainTerrain, tMainTerrain],		// terrains
-		[3]		// widths
-	);
-	elevationPainter = new SmoothElevationPainter(
-		ELEVATION_SET,			// type
-		3,				// elevation
-		3				// blend radius
-	);
-	var newarea = createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], avoidClasses(clLand, 6));
+	var newarea = createArea(
+		new ClumpPlacer(mapArea * 0.01 * lSize, 0.7, 0.1, 10, tx, tz),
+		[
+			new LayeredPainter([tMainTerrain, tMainTerrain], [3]),
+			new SmoothElevationPainter(ELEVATION_SET, landHeight, 3),
+			paintClass(clLand)
+		],
+		avoidClasses(clLand, 6));
+
 	if (newarea !== null)
 	{
 		var distances = [];
@@ -222,10 +212,10 @@ for (var g = 0; g < scaleByMapSize(5,30); g++)
 		var p1 = -1;
 		var p2 = 0;
 
-		for (var i = 0; i < numPlayers; i++)
+		for (let i = 0; i < numPlayers; ++i)
 			distances.push(sqrt((tx-mapSize*playerX[i])*(tx-mapSize*playerX[i])+(tz-mapSize*playerZ[i])*(tz-mapSize*playerZ[i])));
 
-		for (var a = 0; a < numPlayers; a++)
+		for (let a = 0; a < numPlayers; ++a)
 		{
 			if (d1 >= distances[a])
 			{
@@ -241,82 +231,62 @@ for (var g = 0; g < scaleByMapSize(5,30); g++)
 			}
 		}
 
-		var placer = new PathPlacer(tx, tz, mapSize*playerX[p1], mapSize*playerZ[p1], scaleByMapSize(11,17), 0.4, 3*(scaleByMapSize(1,4)), 0.1, 0.1);
-		var terrainPainter = new LayeredPainter(
-			[tMainTerrain, tMainTerrain],		// terrains
-			[3]		// widths
-		);
-		var elevationPainter = new SmoothElevationPainter(
-			ELEVATION_SET,			// type
-			3,				// elevation
-			3				// blend radius
-		);
-		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
+		createArea(
+			new PathPlacer(tx, tz, mapSize * playerX[p1], mapSize * playerZ[p1], scaleByMapSize(11, 17), 0.4, 3 * scaleByMapSize(1, 4), 0.1, 0.1),
+			[
+				new LayeredPainter([tMainTerrain, tMainTerrain], [3]),
+				new SmoothElevationPainter(ELEVATION_SET, landHeight, 3),
+				paintClass(clLand)
+			],
+			null);
 
 		if (numPlayers > 1)
-		{
-			var placer = new PathPlacer(tx, tz, mapSize*playerX[p2], mapSize*playerZ[p2], scaleByMapSize(11,17), 0.4, 3*(scaleByMapSize(1,4)), 0.1, 0.1);
-			var terrainPainter = new LayeredPainter(
-				[tMainTerrain, tMainTerrain],		// terrains
-				[3]		// widths
-			);
-			var elevationPainter = new SmoothElevationPainter(
-				ELEVATION_SET,			// type
-				3,				// elevation
-				3				// blend radius
-			);
-			createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
-		}
+			createArea(
+				new PathPlacer(tx, tz, mapSize * playerX[p2], mapSize * playerZ[p2], scaleByMapSize(11, 17), 0.4, 3 * scaleByMapSize(1, 4), 0.1, 0.1),
+				[
+					new LayeredPainter([tMainTerrain, tMainTerrain], [3]),
+					new SmoothElevationPainter(ELEVATION_SET, landHeight, 3),
+					paintClass(clLand)
+				],
+				null);
 	}
 }
 
-for (var i = 0; i < numPlayers; i++)
-{
-	if (i+1 == numPlayers)
-	{
-		var placer = new PathPlacer(fractionToTiles(playerX[i]), fractionToTiles(playerZ[i]), fractionToTiles(playerX[0]), fractionToTiles(playerZ[0]), scaleByMapSize(8,13), 0.4, 3*(scaleByMapSize(1,4)), 0.1, 0);
-	}
-	else
-	{
-		var placer = new PathPlacer(fractionToTiles(playerX[i]), fractionToTiles(playerZ[i]), fractionToTiles(playerX[i+1]), fractionToTiles(playerZ[i+1]), scaleByMapSize(8,13), 0.4, 3*(scaleByMapSize(1,4)), 0.1, 0);
-	}
-	var terrainPainter = new LayeredPainter(
-		[tRoadWild, tRoad],		// terrains
-		[1]		// widths
-	);
-	var elevationPainter = new SmoothElevationPainter(
-		ELEVATION_SET,			// type
-		3,				// elevation
-		2				// blend radius
-	);
-	createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand), paintClass(clHill)], null);
-
-	var placer = new PathPlacer(fractionToTiles(playerX[i]), fractionToTiles(playerZ[i]), fractionToTiles(0.5), fractionToTiles(0.5), scaleByMapSize(8,13), 0.4, 3*(scaleByMapSize(1,4)), 0.1, 0);
-	var terrainPainter = new LayeredPainter(
-		[tRoadWild, tRoad],		// terrains
-		[1]		// widths
-	);
-	var elevationPainter = new SmoothElevationPainter(
-		ELEVATION_SET,			// type
-		3,				// elevation
-		2				// blend radius
-	);
-	createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand), paintClass(clHill)], null);
-
-}
-
-for (var i = 0; i < numPlayers; i++)
+for (let i = 0; i < numPlayers; ++i)
 {
 	// create the city patch
 	var cityRadius = radius/3;
 	placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, fractionToTiles(playerX[i]), fractionToTiles(playerZ[i]));
 	var painter = new LayeredPainter([tRoad, tRoad], [1]);
 	createArea(placer, [painter, paintClass(clPlayer)], null);
+
+	log("Creating path from player to center and to neighbor...");
+	let neighbor = i + 1 < numPlayers ? i + 1 : 0;
+	for (let [x, z] of [[playerX[neighbor], playerZ[neighbor]], [0.5, 0.5]])
+		createArea(
+			new PathPlacer(
+				fractionToTiles(playerX[i]),
+				fractionToTiles(playerZ[i]),
+				fractionToTiles(x),
+				fractionToTiles(z),
+				scaleByMapSize(8, 13),
+				0.4,
+				3 * scaleByMapSize(1, 4),
+				0.1,
+				0),
+			[
+				new LayeredPainter([tRoadWild, tRoad], [1]),
+				new SmoothElevationPainter(ELEVATION_SET, landHeight, 2),
+				paintClass(clLand),
+				paintClass(clHill)
+			],
+			null);
 }
 
-placer = new ClumpPlacer(150, 0.6, 0.3, 10, fractionToTiles(0.5), fractionToTiles(0.5));
-var painter = new LayeredPainter([tRoad, tRoad], [1]);
-createArea(placer, [painter, paintClass(clHill)], null);
+createArea(
+	new ClumpPlacer(150, 0.6, 0.3, 10, center, center),
+	new LayeredPainter([tRoad, tRoad], [1]),
+	null);
 
 RMS.SetProgress(20);
 
@@ -438,16 +408,13 @@ createFood
 RMS.SetProgress(85);
 
 log("Creating straggler trees...");
-var types = [oTree1, oTree2, oTree4, oTree3];	// some variation
-createStragglerTrees(types, [avoidClasses(clForest, 1, clHill, 1, clPlayer, 9, clMetal, 6, clRock, 6, clHill2, 1), stayClasses(clLand, 3)]);
+createStragglerTrees(
+	[oTree1, oTree2, oTree4, oTree3],
+	[avoidClasses(clForest, 1, clHill, 1, clPlayer, 9, clMetal, 6, clRock, 6, clHill2, 1), stayClasses(clLand, 3)]);
 
 log("Creating treasures...");
-var fx = fractionToTiles(0.5);
-var fz = fractionToTiles(0.5);
 for (let i = 0; i < randIntInclusive(3, 8); ++i)
-	placeObject(fx + randFloat(-7, 7), fz + randFloat(-7, 7), oWood, 0, randFloat(0, 2 * PI));
-
-for (let i = 0; i < randIntInclusive(3, 8); ++i)
-	placeObject(fx + randFloat(-7, 7), fz + randFloat(-7, 7), oFood, 0, randFloat(0, 2 * PI));
+	for (let template of [oFood, oWood])
+		placeObject(center + randFloat(-7, 7), center + randFloat(-7, 7), template, 0, randFloat(0, 2 * Math.PI));
 
 ExportMap();
diff --git a/binaries/data/mods/public/maps/random/continent.js b/binaries/data/mods/public/maps/random/continent.js
index d27d1b81d1..3e4ed69977 100644
--- a/binaries/data/mods/public/maps/random/continent.js
+++ b/binaries/data/mods/public/maps/random/continent.js
@@ -55,24 +55,22 @@ var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clLand = createTileClass();
 
-initTerrain(tWater);
-
-var fx = fractionToTiles(0.5);
-var fz = fractionToTiles(0.5);
-ix = round(fx);
-iz = round(fz);
-
-var placer = new ChainPlacer(2, floor(scaleByMapSize(5, 12)), floor(scaleByMapSize(60, 700)), 1, ix, iz, 0, [floor(mapSize * 0.33)]);
-var terrainPainter = new LayeredPainter(
-	[tMainTerrain, tMainTerrain],		// terrains
-	[3]		// widths
-);
-var elevationPainter = new SmoothElevationPainter(
-	ELEVATION_SET,			// type
-	3,				// elevation
-	4				// blend radius
-);
-createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
+log("Creating continent...");
+createArea(
+	new ChainPlacer(
+		2,
+		Math.floor(scaleByMapSize(5, 12)),
+		Math.floor(scaleByMapSize(60, 700)),
+		1,
+		Math.round(fractionToTiles(0.5)),
+		Math.round(fractionToTiles(0.5)),
+		0,
+		[Math.floor(mapSize * 0.33)]),
+	[
+		new SmoothElevationPainter(ELEVATION_SET, 3, 4),
+		paintClass(clLand)
+	],
+	null);
 
 var [playerIDs, playerX, playerZ] = radialPlayerPlacement(0.25);
 
@@ -292,8 +290,10 @@ createFood
 RMS.SetProgress(85);
 
 log("Creating straggler trees...");
-var types = [oTree1, oTree2, oTree4, oTree3];	// some variation
-createStragglerTrees(types, [avoidClasses(clForest, 7, clHill, 1, clPlayer, 9, clMetal, 6, clRock, 6), stayClasses(clLand, 7)]);
+createStragglerTrees(
+	[oTree1, oTree2, oTree4, oTree3],
+	[avoidClasses(clForest, 7, clHill, 1, clPlayer, 9, clMetal, 6, clRock, 6), stayClasses(clLand, 7)]);
+
 setWaterWaviness(1.0);
 setWaterType("ocean");
 
diff --git a/binaries/data/mods/public/maps/random/corinthian_isthmus.js b/binaries/data/mods/public/maps/random/corinthian_isthmus.js
index 2c304a8950..45df626ab5 100644
--- a/binaries/data/mods/public/maps/random/corinthian_isthmus.js
+++ b/binaries/data/mods/public/maps/random/corinthian_isthmus.js
@@ -300,8 +300,9 @@ createFood
 RMS.SetProgress(90);
 
 log("Creating straggler trees...");
-var types = [oDatePalm, oSDatePalm, oCarob, oFanPalm, oPoplar, oCypress];	// some variation
-createStragglerTrees(types, avoidClasses(clForest, 1, clWater, 2, clPlayer, 8, clMetal, 6, clHill, 1));
+createStragglerTrees(
+	[oDatePalm, oSDatePalm, oCarob, oFanPalm, oPoplar, oCypress],
+	avoidClasses(clForest, 1, clWater, 2, clPlayer, 8, clMetal, 6, clHill, 1));
 
 setSkySet("sunny");
 setSunColor(0.917, 0.828, 0.734);
diff --git a/binaries/data/mods/public/maps/random/cycladic_archipelago.js b/binaries/data/mods/public/maps/random/cycladic_archipelago.js
index a7be88da82..d627b1d8e1 100644
--- a/binaries/data/mods/public/maps/random/cycladic_archipelago.js
+++ b/binaries/data/mods/public/maps/random/cycladic_archipelago.js
@@ -192,10 +192,8 @@ for (let i = 0; i < numPlayers; ++i)
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 }
-RMS.SetProgress(15);
 
 log("Populating islands ...");
-//nPlayer is the player we are on i is the island we are on
 var nPlayer = 0;
 for (let i = 0; i < numIslands; ++i)
 	if (numPlayers >= 6 || i == startingPlaces[numPlayers-1][nPlayer])
@@ -221,62 +219,53 @@ for (let i = 0; i < numIslands; ++i)
 RMS.SetProgress(20);
 
 log("Creating bumps...");
-placer = new ClumpPlacer(scaleByMapSize(20, 60), 0.3, 0.06, 1);
-painter = new SmoothElevationPainter(ELEVATION_MODIFY, 2, 3);
 createAreasInAreas(
-	placer,
-	painter,
+	new ClumpPlacer(scaleByMapSize(20, 60), 0.3, 0.06, 1),
+	new SmoothElevationPainter(ELEVATION_MODIFY, 2, 3),
 	avoidClasses(clCity, 0),
 	scaleByMapSize(25, 75),15,
-	areas
-);
+	areas);
+
 RMS.SetProgress(34);
 
 log("Creating hills...");
-placer = new ClumpPlacer(scaleByMapSize(20, 150), 0.2, 0.1, 1);
-var terrainPainter = new LayeredPainter(
-	[tCliff, tCliffShrubs],		// terrains
-	[2]								// widths
-);
-var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 12, 2);
 createAreasInAreas(
-	placer,
-	[terrainPainter, elevationPainter, paintClass(clHill)],
+	new ClumpPlacer(scaleByMapSize(20, 150), 0.2, 0.1, 1),
+	[
+		new LayeredPainter([tCliff, tCliffShrubs], [2]),
+		new SmoothElevationPainter(ELEVATION_SET, 12, 2),
+		paintClass(clHill)
+	],
 	avoidClasses(clCity, 15, clHill, 15),
 	scaleByMapSize(5, 30), 15,
-	areas
-);
+	areas);
+
 RMS.SetProgress(38);
 
-// Find all water
 for (var ix = 0; ix < mapSize; ix++)
 	for (var iz = 0; iz < mapSize; iz++)
 		if (getHeight(ix,iz) < 0)
 			addToClass(ix,iz,clWater);
 
 log("Creating forests...");
-var types = [
+var forestTypes = [
 	[[tForestFloor, tGrass, pPalmForest], [tForestFloor, pPalmForest]],
 	[[tForestFloor, tGrass, pPineForest], [tForestFloor, pPineForest]],
 	[[tForestFloor, tGrass, pPoplarForest], [tForestFloor, pPoplarForest]],
 	[[tForestFloor, tGrass, pMainForest], [tForestFloor, pMainForest]]
-];	// some variation
-var size = 5; //size
-var num = scaleByMapSize(10, 64); //number
-for (var i = 0; i < types.length; ++i)
-{
-	placer = new ClumpPlacer(randIntInclusive(6, 17), 0.1, 0.1, 1);
-	painter = new LayeredPainter(
-		types[i],		// terrains
-		[2]											// widths
-		);
+];
+
+for (let type of forestTypes)
 	createAreasInAreas(
-		placer,
-		[painter, paintClass(clForest)],
+		new ClumpPlacer(randIntInclusive(6, 17), 0.1, 0.1, 1),
+		[
+			new LayeredPainter(type, [2]),
+			paintClass(clForest)
+		],
 		avoidClasses(clCity, 1, clWater, 3, clForest, 3, clHill, 1, clBaseResource, 4),
-		num, 20, areas
-	);
-}
+		scaleByMapSize(10, 64),
+		20,
+		areas);
 RMS.SetProgress(42);
 
 log("Creating stone mines...");
@@ -288,7 +277,7 @@ createObjectGroupsByAreasDeprecated(group, 0,
 RMS.SetProgress(46);
 
 log("Creating small stone mines...");
-group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
+var group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroupsByAreasDeprecated(group, 0,
 	[avoidClasses(clWater, 1, clForest, 1, clHill, 1, clPlayer, 5, clRock, 2)],
 	scaleByMapSize(4,16), 200, areas
@@ -304,33 +293,31 @@ createObjectGroupsByAreasDeprecated(group, 0,
 RMS.SetProgress(54);
 
 log("Creating shrub patches...");
-var sizes = [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)];
-for (var i = 0; i < sizes.length; i++)
-{
-	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
-	painter = new LayeredPainter([tBeachBlend,tGrassShrubs],[1]);
+for (let size of [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)])
 	createAreasInAreas(
-		placer,
-		[painter, paintClass(clDirt)],
+		new ClumpPlacer(size, 0.3, 0.06, 0.5),
+		[
+			new LayeredPainter([tBeachBlend, tGrassShrubs], [1]),
+			paintClass(clDirt)
+		],
 		avoidClasses(clWater, 3, clHill, 0, clDirt, 6, clCity, 0, clBaseResource, 4),
-		scaleByMapSize(4, 16), 20, areas
-	);
-}
+		scaleByMapSize(4, 16),
+		20,
+		areas);
 RMS.SetProgress(58);
 
 log("Creating grass patches...");
-var sizes = [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)];
-for (var i = 0; i < sizes.length; i++)
-{
-	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
-	painter = new LayeredPainter([tGrassDry],[]);
+for (let size of [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)])
 	createAreasInAreas(
-		placer,
-		[painter, paintClass(clDirt)],
+		new ClumpPlacer(size, 0.3, 0.06, 0.5),
+		[
+			new LayeredPainter([tGrassDry], []),
+			paintClass(clDirt)
+		],
 		avoidClasses(clWater, 3, clHill, 0, clDirt, 6, clCity, 0, clBaseResource, 4),
-		scaleByMapSize(4, 16), 20, areas
-	);
-}
+		scaleByMapSize(4, 16),
+		20,
+		areas);
 RMS.SetProgress(62);
 
 log("Creating straggler trees...");
diff --git a/binaries/data/mods/public/maps/random/english_channel.js b/binaries/data/mods/public/maps/random/english_channel.js
index 4059e789ad..b72673532e 100644
--- a/binaries/data/mods/public/maps/random/english_channel.js
+++ b/binaries/data/mods/public/maps/random/english_channel.js
@@ -36,7 +36,6 @@ const aBushSmall = "actor|props/flora/bush_medit_sm_lush.xml";
 const aReeds = "actor|props/flora/reeds_pond_lush_a.xml";
 const aLillies = "actor|props/flora/water_lillies.xml";
 
-// terrain + entity (for painting)
 const pForestD = [tGrassDForest + TERRAIN_SEPARATOR + oBeech, tGrassDForest];
 
 InitMap();
@@ -165,7 +164,7 @@ paintRiver({
 
 RMS.SetProgress(20);
 
-log("Creating rivers");
+log("Creating tributaries...");
 for (let i = 0; i <= randIntInclusive(8, scaleByMapSize(12, 20)); ++i)
 {
 	var cLocation = randFloat(0.05, 0.95);
@@ -173,36 +172,64 @@ for (let i = 0; i <= randIntInclusive(8, scaleByMapSize(12, 20)); ++i)
 	var sign = randBool() ? 1 : -1;
 	var tang = sign * PI * randFloat(0.2, 0.8);
 	var cDistance = sign * 0.05;
+	let someRadius = scaleByMapSize(10, 20);
 
-	var point = getTIPIADBON([fractionToTiles(cLocation), fractionToTiles(0.5 + cDistance)], [fractionToTiles(cLocation), fractionToTiles(0.5 - cDistance)], [-6, -1.5], 0.5, 4, 0.01);
-	if (point !== undefined)
-	{
-		var placer = new PathPlacer(floor(point[0]), floor(point[1]), floor(fractionToTiles(0.5 + 0.49*cos(tang))), floor(fractionToTiles(0.5 + 0.49*sin(tang))), scaleByMapSize(10,20), 0.4, 3*(scaleByMapSize(1,4)), 0.1, 0.05);
-		var terrainPainter = new LayeredPainter(
-			[tShore, tWater, tWater],		// terrains
-			[1, 3]								// widths
-		);
-		var elevationPainter = new SmoothElevationPainter(
-			ELEVATION_SET,			// type
-			-4,				// elevation
-			4				// blend radius
-		);
-		var success = createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 8, clWater, 3, clShallow, 2));
-		if (success !== undefined)
-		{
-			placer = new ClumpPlacer(floor(PI*scaleByMapSize(10,20)*scaleByMapSize(10,20)/4), 0.95, 0.6, 10, fractionToTiles(0.5 + 0.49*cos(tang)), fractionToTiles(0.5 + 0.49*sin(tang)));
-			var painter = new LayeredPainter(
-				[tShore, tWater, tWater],		// terrains
-				[1, 3]								// widths);
-			);
-			var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -3, 3);
-			createArea(placer, [painter, elevationPainter], avoidClasses(clPlayer, 23));
-		}
-	}
+	let point = getTIPIADBON(
+		[fractionToTiles(cLocation), fractionToTiles(0.5 + cDistance)],
+		[fractionToTiles(cLocation), fractionToTiles(0.5 - cDistance)],
+		[-6, -1.5],
+		0.5,
+		4,
+		0.01);
+
+	if (!point)
+		continue;
+
+	if (!createArea(
+		new PathPlacer(
+			Math.floor(point[0]),
+			Math.floor(point[1]),
+			Math.floor(fractionToTiles(0.5 + 0.49 * Math.cos(tang))),
+			Math.floor(fractionToTiles(0.5 + 0.49 * Math.sin(tang))),
+			someRadius,
+			0.4,
+			3 * scaleByMapSize(1, 4),
+			0.1,
+			0.05),
+		[
+			new SmoothElevationPainter(ELEVATION_SET, -4, 4),
+			paintClass(clWater)
+		],
+		avoidClasses(clPlayer, 8, clWater, 3, clShallow, 2)))
+		continue;
+
+	log("Creating small puddles at the map border to ensure players being separated...");
+	createArea(
+		new ClumpPlacer(
+			Math.floor(Math.PI * Math.pow(someRadius / 2, 2)),
+			0.95,
+			0.6,
+			10,
+			fractionToTiles(0.5 + 0.49 * Math.cos(tang)),
+			fractionToTiles(0.5 + 0.49 * Math.sin(tang))),
+		new SmoothElevationPainter(ELEVATION_SET, -3, 3),
+		avoidClasses(clPlayer, 23));
 }
 
-passageMaker(round(fractionToTiles(0.2)), round(fractionToTiles(0.25)), round(fractionToTiles(0.8)), round(fractionToTiles(0.25)), scaleByMapSize(4,8), -2, -2, 2, clShallow, undefined, -4);
-passageMaker(round(fractionToTiles(0.2)), round(fractionToTiles(0.75)), round(fractionToTiles(0.8)), round(fractionToTiles(0.75)), scaleByMapSize(4,8), -2, -2, 2, clShallow, undefined, -4);
+log("Creating shallows in tributaries...");
+for (let z of [0.25, 0.75])
+	passageMaker(
+		Math.round(fractionToTiles(0.2)),
+		Math.round(fractionToTiles(z)),
+		Math.round(fractionToTiles(0.8)),
+		Math.round(fractionToTiles(z)),
+		scaleByMapSize(4, 8),
+		-2,
+		-2,
+		2,
+		clShallow,
+		undefined,
+		-4);
 
 paintTerrainBasedOnHeight(-5, 1, 1, tWater);
 paintTerrainBasedOnHeight(1, 3, 1, tShore);
@@ -326,8 +353,9 @@ createFood
 );
 
 log("Creating straggler trees...");
-var types = [oBeech, oPoplar, oApple];	// some variation
-createStragglerTrees(types, avoidClasses(clWater, 1, clForest, 1, clHill, 1, clPlayer, 8, clMetal, 6, clRock, 6));
+createStragglerTrees(
+	[oBeech, oPoplar, oApple],
+	avoidClasses(clWater, 1, clForest, 1, clHill, 1, clPlayer, 8, clMetal, 6, clRock, 6));
 
 setSkySet("cirrus");
 setWaterColor(0.114, 0.192, 0.463);
diff --git a/binaries/data/mods/public/maps/random/extinct_volcano.js b/binaries/data/mods/public/maps/random/extinct_volcano.js
index 077c2dd44d..572a835a12 100644
--- a/binaries/data/mods/public/maps/random/extinct_volcano.js
+++ b/binaries/data/mods/public/maps/random/extinct_volcano.js
@@ -221,11 +221,11 @@ var types = [
 ];
 var size = numForest / (scaleByMapSize(4, 12) * numPlayers);
 var num = Math.floor(size / types.length);
-for (let i = 0; i < types.length; ++i)
+for (let type of types)
 	createAreas(
 		new ClumpPlacer(numForest / num, 0.1, 0.1, 1),
 		[
-			new LayeredPainter(types[i], [2]),
+			new LayeredPainter(type, [2]),
 			paintClass(clForest)
 		],
 		avoidClasses(
diff --git a/binaries/data/mods/public/maps/random/flood.js b/binaries/data/mods/public/maps/random/flood.js
index 24793eac97..3ebec41ce0 100644
--- a/binaries/data/mods/public/maps/random/flood.js
+++ b/binaries/data/mods/public/maps/random/flood.js
@@ -15,16 +15,15 @@ const tRoadWild = g_Terrains.roadWild;
 const tTier4Terrain = g_Terrains.tier4Terrain;
 const tShore = g_Terrains.shore;
 const tWater = g_Terrains.water;
-let tHill = g_Terrains.hill;
-let tDirt = g_Terrains.dirt;
 
+var tHill = g_Terrains.hill;
+var tDirt = g_Terrains.dirt;
 if (currentBiome() == "temperate")
 {
 	tDirt = ["medit_shrubs_a", "grass_field"];
 	tHill = ["grass_field", "peat_temp"];
 }
 
-// Gaia entities
 const oTree1 = g_Gaia.tree1;
 const oTree2 = g_Gaia.tree2;
 const oTree3 = g_Gaia.tree3;
@@ -37,7 +36,6 @@ const oSecondaryHuntableAnimal = g_Gaia.secondaryHuntableAnimal;
 const oStoneLarge = g_Gaia.stoneLarge;
 const oMetalLarge = g_Gaia.metalLarge;
 
-// Decorative props
 const aGrass = g_Decoratives.grass;
 const aGrassShort = g_Decoratives.grassShort;
 const aRockLarge = g_Decoratives.rockLarge;
@@ -51,46 +49,40 @@ const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TE
 InitMap();
 
 const radius = scaleByMapSize(15, 25);
-const elevation = 2;
-const shoreRadius = 6;
+const clPlayer = createTileClass();
+const clHill = createTileClass();
+const clMountain = createTileClass();
+const clForest = createTileClass();
+const clWater = createTileClass();
+const clDirt = createTileClass();
+const clRock = createTileClass();
+const clMetal = createTileClass();
+const clFood = createTileClass();
+const clBaseResource = createTileClass();
+
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
-const mapArea = mapSize * mapSize;
 const centerOfMap = mapSize / 2;
 
-let clPlayer = createTileClass();
-let clHill = createTileClass();
-let clMountain = createTileClass();
-let clForest = createTileClass();
-let clWater = createTileClass();
-let clDirt = createTileClass();
-let clRock = createTileClass();
-let clMetal = createTileClass();
-let clFood = createTileClass();
-let clBaseResource = createTileClass();
+const landHeight = 2;
+const waterHeight = getMapBaseHeight();
+const shoreRadius = 6;
 
 initTerrain(tWater);
 
+log("Creating the water...");
+createArea(
+	new ClumpPlacer(getMapArea(), 1, 1, 1, Math.round(fractionToTiles(0.5)), Math.round(fractionToTiles(0.5))),
+	[
+		new LayeredPainter([tWater, tWater, tShore], [1, 4]),
+		new SmoothElevationPainter(ELEVATION_SET, waterHeight, 2),
+		paintClass(clWater)
+	],
+	avoidClasses(clPlayer, 5));
+
 var [playerIDs, playerX, playerZ] = radialPlayerPlacement(0.38);
 
-let fx = fractionToTiles(0.5);
-let fz = fractionToTiles(0.5);
-let ix = round(fx);
-let iz = round(fz);
-
-// Create the water
-let placer = new ClumpPlacer(mapArea * 1, 1, 1, 1, ix, iz);
-let terrainPainter = new LayeredPainter(
-    [tWater, tWater, tShore], // terrains
-    [1, 4] // widths
-);
-let elevationPainter = new SmoothElevationPainter(
-   ELEVATION_SET,      // type
-   getMapBaseHeight(), // elevation
-   2                   // blend radius
-);
-createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 5));
-
+log("Creating player islands...")
 for (let i = 0; i < numPlayers; ++i)
 {
 	let id = playerIDs[i];
@@ -104,18 +96,20 @@ for (let i = 0; i < numPlayers; ++i)
 
 	let hillSize = PI * radius * radius * 2;
 
-	// Create the hill
-	let placer = new ClumpPlacer(hillSize, 0.80, 0.1, 10, ix, iz);
-	let terrainPainter = new LayeredPainter(
-		[tShore, tMainTerrain],	// terrains
-		[shoreRadius] // widths
-	);
-	let elevationPainter = new SmoothElevationPainter(
-		ELEVATION_SET,			// type
-		elevation,				// elevation
-		shoreRadius				// blend radius
-	);
-	createArea(placer, [terrainPainter, elevationPainter, paintClass(clHill)], null);
+	createArea(
+		new ClumpPlacer(
+			hillSize,
+			0.8,
+			0.1,
+			10,
+			Math.round(fractionToTiles(playerX[i])),
+			Math.round(fractionToTiles(playerZ[i]))),
+		[
+			new LayeredPainter([tShore, tMainTerrain], [shoreRadius]),
+			new SmoothElevationPainter(ELEVATION_SET, landHeight, shoreRadius),
+			paintClass(clHill)
+		],
+		null);
 
 	addCivicCenterAreaToClass(ix, iz, clPlayer);
 
@@ -123,7 +117,7 @@ for (let i = 0; i < numPlayers; ++i)
 
 	// Create the city patch
 	let cityRadius = radius/3;
-	placer = new ClumpPlacer(PI * cityRadius * cityRadius, 0.6, 0.3, 10, ix, iz);
+	let placer = new ClumpPlacer(PI * cityRadius * cityRadius, 0.6, 0.3, 10, ix, iz);
 	let painter = new LayeredPainter([tRoadWild, tRoad], [1]);
 	createArea(placer, painter, null);
 
@@ -186,95 +180,104 @@ for (let i = 0; i < numPlayers; ++i)
 
 RMS.SetProgress(40);
 
-// Create central island
-placer = new ChainPlacer(floor(scaleByMapSize(6, 6)), floor(scaleByMapSize(10, 15)), floor(scaleByMapSize(200, 300)), 1, centerOfMap, centerOfMap, 0, [floor(mapSize * 0.01)]);
-terrainPainter = new LayeredPainter(
-	[tShore, tMainTerrain], // terrains
-	[shoreRadius, 100]      // widths
-);
-elevationPainter = new SmoothElevationPainter(
-	ELEVATION_SET, // type
-	elevation,     // elevation
-	shoreRadius    // blend radius
-);
-createArea(placer, [terrainPainter, elevationPainter, paintClass(clHill)], avoidClasses(clPlayer, 40));
+log("Creating central island...");
+createArea(
+	new ChainPlacer(
+		6,
+		Math.floor(scaleByMapSize(10, 15)),
+		Math.floor(scaleByMapSize(200, 300)),
+		1,
+		centerOfMap,
+		centerOfMap,
+		0,
+		[Math.floor(mapSize * 0.01)]),
+	[
+		new LayeredPainter([tShore, tMainTerrain], [shoreRadius, 100]),
+		new SmoothElevationPainter(ELEVATION_SET, landHeight, shoreRadius),
+		paintClass(clHill)
+	],
+	avoidClasses(clPlayer, 40));
 
 for (let m = 0; m < randIntInclusive(20, 34); ++m)
 {
-	let placer = new ChainPlacer(
-		Math.floor(scaleByMapSize(7, 7)),
-		Math.floor(scaleByMapSize(15, 15)),
-		Math.floor(scaleByMapSize(15, 20)),
-		1,
-		randIntExclusive(0, mapSize),
-		randIntExclusive(0, mapSize),
-		0,
-		[Math.floor(mapSize * 0.01)]);
-
 	let elevRand = randIntInclusive(6, 20);
-	let terrainPainter = new LayeredPainter(
-		[tDirt, tHill],        // terrains
-		[floor(elevRand / 3), 40]       // widths
-	);
-	let elevationPainter = new SmoothElevationPainter(
-		ELEVATION_SET,      // type
-		elevRand,           // elevation
-		floor(elevRand / 3)	// blend radius
-	);
-	createArea(placer, [terrainPainter, elevationPainter, paintClass(clHill)], [avoidClasses(clBaseResource, 2, clPlayer, 40), stayClasses(clHill, 6)]);
+	createArea(
+		new ChainPlacer(
+			7,
+			15,
+			Math.floor(scaleByMapSize(15, 20)),
+			1,
+			randIntExclusive(0, mapSize),
+			randIntExclusive(0, mapSize),
+			0,
+			[Math.floor(mapSize * 0.01)]),
+		[
+			new LayeredPainter([tDirt, tHill], [Math.floor(elevRand / 3), 40]),
+			new SmoothElevationPainter(ELEVATION_SET, elevRand, Math.floor(elevRand / 3)),
+			paintClass(clHill)
+		],
+		[avoidClasses(clBaseResource, 2, clPlayer, 40), stayClasses(clHill, 6)]);
 }
 
 for (let m = 0; m < randIntInclusive(8, 17); ++m)
 {
-	let placer = new ChainPlacer(
-		Math.floor(scaleByMapSize(5, 5)),
-		Math.floor(scaleByMapSize(8, 8)),
-		Math.floor(scaleByMapSize(15, 20)),
-		1,
-		randIntExclusive(0, mapSize),
-		randIntExclusive(0, mapSize),
-		0,
-		[Math.floor(mapSize * 0.01)]);
-
 	let elevRand = randIntInclusive(15, 29);
-	let terrainPainter = new LayeredPainter(
-		[tCliff, tForestFloor2],        // terrains
-		[floor(elevRand / 3), 40]       // widths
-	);
-	let elevationPainter = new SmoothElevationPainter(
-		ELEVATION_MODIFY,   // type
-		elevRand,           // elevation
-		floor(elevRand / 3) // blend radius
-	);
-	createArea(placer, [terrainPainter, elevationPainter, paintClass(clMountain)], [avoidClasses(clBaseResource, 2, clPlayer, 40), stayClasses(clHill, 6)]);
+	createArea(
+		new ChainPlacer(
+				5,
+				8,
+				Math.floor(scaleByMapSize(15, 20)),
+				1,
+				randIntExclusive(0, mapSize),
+				randIntExclusive(0, mapSize),
+				0,
+				[Math.floor(mapSize * 0.01)]),
+		[
+			new LayeredPainter([tCliff, tForestFloor2], [Math.floor(elevRand / 3), 40]),
+			new SmoothElevationPainter(ELEVATION_MODIFY, elevRand, Math.floor(elevRand / 3)),
+			paintClass(clMountain)
+		],
+		[avoidClasses(clBaseResource, 2, clPlayer, 40), stayClasses(clHill, 6)]);
 }
 
-// Create center bounty
-let group = new SimpleGroup(
-	[new SimpleObject(oMetalLarge, 3, 6, 25, floor(mapSize * 0.25))],
-	true, clBaseResource, centerOfMap, centerOfMap
-);
-createObjectGroup(group, 0, [avoidClasses(clBaseResource, 20, clPlayer, 40, clMountain, 4), stayClasses(clHill, 10)]);
-group = new SimpleGroup(
-	[new SimpleObject(oStoneLarge, 3, 6, 25, floor(mapSize * 0.25))],
-	true, clBaseResource, centerOfMap, centerOfMap
-);
-createObjectGroup(group, 0, [avoidClasses(clBaseResource, 20, clPlayer, 40, clMountain, 4), stayClasses(clHill, 10)]);
-group = new SimpleGroup(
-	[new SimpleObject(oMainHuntableAnimal, floor(6 * numPlayers), floor(6 * numPlayers), 2, floor(mapSize * 0.1))],
-	true, clBaseResource, centerOfMap, centerOfMap
-);
-createObjectGroup(group, 0, [avoidClasses(clBaseResource, 2, clMountain, 4, clPlayer, 40, clWater, 2), stayClasses(clHill, 10)]);
+log("Creating center bounty...");
+createObjectGroup(
+	new SimpleGroup(
+		[new SimpleObject(oMetalLarge, 3, 6, 25, Math.floor(mapSize * 0.25))],
+		true,
+		clBaseResource,
+		centerOfMap,
+		centerOfMap),
+	0,
+	[avoidClasses(clBaseResource, 20, clPlayer, 40, clMountain, 4), stayClasses(clHill, 10)]);
+
+createObjectGroup(
+	new SimpleGroup(
+		[new SimpleObject(oStoneLarge, 3, 6, 25, Math.floor(mapSize * 0.25))],
+		true,
+		clBaseResource,
+		centerOfMap,
+		centerOfMap),
+		0,
+		[avoidClasses(clBaseResource, 20, clPlayer, 40, clMountain, 4), stayClasses(clHill, 10)]);
+
+createObjectGroup(
+	new SimpleGroup(
+		[new SimpleObject(oMainHuntableAnimal, Math.floor(6 * numPlayers), Math.floor(6 * numPlayers), 2, Math.floor(mapSize * 0.1))],
+		true,
+		clBaseResource,
+		centerOfMap,
+		centerOfMap),
+	0,
+	[avoidClasses(clBaseResource, 2, clMountain, 4, clPlayer, 40, clWater, 2), stayClasses(clHill, 10)]);
 
 log("Creating fish...");
-group = new SimpleGroup(
-	[new SimpleObject(oFish, 2, 3, 0, 2)],
-	true, clFood
-);
-createObjectGroupsDeprecated(group, 0,
+createObjectGroupsDeprecated(
+	new SimpleGroup([new SimpleObject(oFish, 2, 3, 0, 2)], true, clFood),
+	0,
 	avoidClasses(clHill, 10, clFood, 20),
-	10 * numPlayers, 60
-);
+	10 * numPlayers,
+	60);
 
 createForests(
 	[tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
@@ -290,41 +293,28 @@ createStragglerTrees(types, [avoidClasses(clBaseResource, 2, clMetal, 6, clRock,
 RMS.SetProgress(65);
 
 log("Creating dirt patches...");
-let sizes = [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)];
-let numb = currentBiome() == "savanna" ? 3 : 1;
-
-for (let i = 0; i < sizes.length; ++i)
-{
-	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
-	let painter = new LayeredPainter(
-		[[tMainTerrain, tTier1Terrain], [tTier1Terrain, tTier2Terrain], [tTier2Terrain, tTier3Terrain]], // terrains
-		[1, 1] // widths
-	);
+var numb = currentBiome() == "savanna" ? 3 : 1;
+for (let size of [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)])
 	createAreas(
-		placer,
-		[painter, paintClass(clDirt)],
+		new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
+		[
+			new LayeredPainter([[tMainTerrain, tTier1Terrain], [tTier1Terrain, tTier2Terrain], [tTier2Terrain, tTier3Terrain]], [1, 1]),
+			paintClass(clDirt)
+		],
 		avoidClasses(clForest, 0, clMountain, 0, clDirt, 5, clPlayer, 10),
-		numb * scaleByMapSize(15, 45)
-	);
-}
+		numb * scaleByMapSize(15, 45));
 
 log("Painting shorelines...");
-paintTerrainBasedOnHeight(1, 2, 0, tMainTerrain);
-paintTerrainBasedOnHeight(getMapBaseHeight(), 1, 3, tTier1Terrain);
+paintTerrainBasedOnHeight(1, landHeight, 0, tMainTerrain);
+paintTerrainBasedOnHeight(waterHeight, 1, 3, tTier1Terrain);
 
 log("Creating grass patches...");
-sizes = [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)];
-for (let i = 0; i < sizes.length; ++i)
-{
-	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
-	let painter = new TerrainPainter(tTier4Terrain);
+for (let size of [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)])
 	createAreas(
-		placer,
-		painter,
+		new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
+		new TerrainPainter(tTier4Terrain),
 		avoidClasses(clForest, 0, clMountain, 0, clDirt, 5, clPlayer, 10),
-		numb * scaleByMapSize(15, 45)
-	);
-}
+		numb * scaleByMapSize(15, 45));
 
 log("Creating food...");
 createFood(
@@ -352,9 +342,8 @@ log("Creating more straggeler trees...");
 createStragglerTrees(types, avoidClasses(clWater, 5, clForest, 7, clMountain, 1, clPlayer, 30, clMetal, 6, clRock, 3));
 
 log("Creating decoration...");
-let planetm = currentBiome() == "tropic" ? 8 : 1;
-createDecoration
-(
+var planetm = currentBiome() == "tropic" ? 8 : 1;
+createDecoration(
 	[
 		[new SimpleObject(aRockMedium, 1, 3, 0, 1)],
 		[new SimpleObject(aRockLarge, 1, 2, 0, 1), new SimpleObject(aRockMedium, 1, 3, 0, 2)],
@@ -369,8 +358,7 @@ createDecoration
 		planetm * scaleByMapSize(13, 200),
 		planetm * scaleByMapSize(13, 200)
 	],
-	avoidClasses(clForest, 2, clPlayer, 20, clMountain, 5, clFood, 1, clBaseResource, 2)
-);
+	avoidClasses(clForest, 2, clPlayer, 20, clMountain, 5, clFood, 1, clBaseResource, 2));
 
 log("Creating water forests...");
 createForests(
@@ -381,13 +369,11 @@ createForests(
 	...rBiomeTreeCount(0.1));
 
 log("Creating small grass tufts...");
-group = new SimpleGroup(
-	[new SimpleObject(aGrassShort, 1, 2, 0, 1, -PI / 8, PI / 8)]
-);
-createObjectGroupsDeprecated(group, 0,
+createObjectGroupsDeprecated(
+	new SimpleGroup([new SimpleObject(aGrassShort, 1, 2, 0, 1)]),
+	0,
 	[avoidClasses(clMountain, 2, clPlayer, 2, clDirt, 0), stayClasses(clHill, 8)],
-	planetm * scaleByMapSize(13, 200)
-);
+	planetm * scaleByMapSize(13, 200));
 
 setSkySet(pickRandom(["cloudless", "cumulus", "overcast"]));
 setWaterMurkiness(0.4);
diff --git a/binaries/data/mods/public/maps/random/fortress.js b/binaries/data/mods/public/maps/random/fortress.js
index effcc091f9..74c0d2ca4d 100644
--- a/binaries/data/mods/public/maps/random/fortress.js
+++ b/binaries/data/mods/public/maps/random/fortress.js
@@ -159,29 +159,26 @@ for (var i=0; i < numPlayers; i++)
 
 log("Creating lakes...");
 var numLakes = round(scaleByMapSize(1,4) * numPlayers);
-var placer = new ClumpPlacer(scaleByMapSize(100,250), 0.8, 0.1, 10);
-var terrainPainter = new LayeredPainter(
-	[tShore, tWater, tWater],		// terrains
-	[1,1]							// widths
-);
-var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -4, 3);
 var waterAreas = createAreas(
-	placer,
-	[terrainPainter, elevationPainter, paintClass(clWater)],
+	new ClumpPlacer(scaleByMapSize(100,250), 0.8, 0.1, 10),
+	[
+		new LayeredPainter([tShore, tWater, tWater], [1, 1]),
+		new SmoothElevationPainter(ELEVATION_SET, -4, 3),
+		paintClass(clWater)
+	],
 	avoidClasses(clPlayer, 7, clWater, 20),
-	numLakes
-);
+	numLakes);
+
 RMS.SetProgress(15);
 
 log("Creating reeds...");
-group = new SimpleGroup(
-	[new SimpleObject(aReeds, 5,10, 0,4), new SimpleObject(aLillies, 0,1, 0,4)], true
-);
-createObjectGroupsByAreasDeprecated(group, 0,
+createObjectGroupsByAreasDeprecated(
+	new SimpleGroup([new SimpleObject(aReeds, 5,10, 0,4), new SimpleObject(aLillies, 0,1, 0,4)], true),
+	0,
 	[borderClasses(clWater, 3, 0), stayClasses(clWater, 1)],
 	numLakes, 100,
-	waterAreas
-);
+	waterAreas);
+
 RMS.SetProgress(25);
 
 log("Creating fish...");
@@ -194,8 +191,7 @@ createObjectGroupsByAreasDeprecated(
 	[stayClasses(clWater, 4),  avoidClasses(clFood, 8)],
 	numLakes / 4,
 	50,
-	waterAreas
-);
+	waterAreas);
 RMS.SetProgress(30);
 
 createBumps(avoidClasses(clWater, 2, clPlayer, 5));
@@ -219,23 +215,18 @@ var types = [
 	[[tForestFloor, tGrass, pForestD], [tForestFloor, pForestD]],
 	[[tForestFloor, tGrass, pForestO], [tForestFloor, pForestO]],
 	[[tForestFloor, tGrass, pForestP], [tForestFloor, pForestP]]
-];	// some variation
+];
 var size = numForest / (scaleByMapSize(3,6) * numPlayers);
 var num = floor(size / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), numForest / num, 0.5);
-	var painter = new LayeredPainter(
-		types[i],		// terrains
-		[2]											// widths
-		);
+for (let type of types)
 	createAreas(
-		placer,
-		[painter, paintClass(clForest)],
+		new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), numForest / num, 0.5),
+		[
+			new LayeredPainter(type, [2]),
+			paintClass(clForest)
+		],
 		avoidClasses(clPlayer, 5, clWater, 3, clForest, 15, clHill, 1),
-		num
-	);
-}
+		num);
 RMS.SetProgress(50);
 
 log("Creating dirt patches...");
@@ -322,8 +313,9 @@ createFood
 RMS.SetProgress(90);
 
 log("Creating straggler trees...");
-var types = [oOak, oBeech, oPine];	// some variation
-createStragglerTrees(types, avoidClasses(clWater, 1, clForest, 1, clHill, 1, clPlayer, 1, clMetal, 6, clRock, 6));
+createStragglerTrees(
+	[oOak, oBeech, oPine],
+	avoidClasses(clWater, 1, clForest, 1, clHill, 1, clPlayer, 1, clMetal, 6, clRock, 6));
 RMS.SetProgress(95);
 
 setSkySet("sunny");
diff --git a/binaries/data/mods/public/maps/random/gear.js b/binaries/data/mods/public/maps/random/gear.js
index be042bc7ae..b9bb637dc7 100644
--- a/binaries/data/mods/public/maps/random/gear.js
+++ b/binaries/data/mods/public/maps/random/gear.js
@@ -48,8 +48,6 @@ const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 const mapArea = mapSize*mapSize;
 
-log(mapSize);
-
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
@@ -62,25 +60,6 @@ var clBaseResource = createTileClass();
 
 initTerrain(tMainTerrain);
 
-var fx = fractionToTiles(0.5);
-var fz = fractionToTiles(0.5);
-var ix = round(fx);
-var iz = round(fz);
-
-var lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 8))));
-
-var placer = new ClumpPlacer(mapArea * 0.23, 1, 1, 10, ix, iz);
-var terrainPainter = new LayeredPainter(
-	[tShore, tWater, tWater, tWater],		// terrains
-	[1, 4, 2]		// widths
-);
-var elevationPainter = new SmoothElevationPainter(
-	ELEVATION_SET,			// type
-	-3,				// elevation
-	4				// blend radius
-);
-createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], null);
-
 var [playerIDs, playerX, playerZ, playerAngle, startAngle] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
@@ -201,106 +180,77 @@ else if (mapSize == 448)
 		split = 2;
 }
 
-log ("Creating rivers...");
-for (var m = 0; m < numPlayers*split; m++)
-{
-	var tang = startAngle + (m+0.5)*TWO_PI/(numPlayers*split);
-	var placer = new PathPlacer(fractionToTiles(0.5 + 0.15*cos(tang)), fractionToTiles(0.5 + 0.15*sin(tang)), fractionToTiles(0.5 + 0.49*cos(tang)), fractionToTiles(0.5 + 0.49*sin(tang)), scaleByMapSize(14,40), 0.0, 3*(scaleByMapSize(1,3)), 0.2, 0.05);
-	var terrainPainter = new LayeredPainter(
-		[tShore, tWater, tWater],		// terrains
-		[1, 3]								// widths
-	);
-	var elevationPainter = new SmoothElevationPainter(
-		ELEVATION_SET,			// type
-		-4,				// elevation
-		4				// blend radius
-	);
-	createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 5));
-	placer = new ClumpPlacer(floor(PI*scaleByMapSize(14,40)*scaleByMapSize(14,40)/4), 1, 0, 10, fractionToTiles(0.5 + 0.49*cos(tang)), fractionToTiles(0.5 + 0.49*sin(tang)));
-	var painter = new LayeredPainter([tWater, tWater], [1]);
-	var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -4, 4);
-	createArea(placer, [painter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 5));
+log ("Creating big circular lake...");
+var center = Math.round(fractionToTiles(0.5));
+createArea(
+	new ClumpPlacer(mapArea * 0.23, 1, 1, 10, center, center),
+	new SmoothElevationPainter(ELEVATION_SET, -3, 4),
+	null);
 
-	var tang = startAngle + (m)*TWO_PI/(numPlayers*split);
-	var placer = new PathPlacer(fractionToTiles(0.5 + 0.05*cos(tang)), fractionToTiles(0.5 + 0.05*sin(tang)), fractionToTiles(0.5 + 0.49*cos(tang)), fractionToTiles(0.5 + 0.49*sin(tang)), scaleByMapSize(10,40), 0.0, 3*(scaleByMapSize(1,3)), 0.2, 0.05);
-	var terrainPainter = new LayeredPainter(
-		[tWater, tShore, tMainTerrain],		// terrains
-		[1, 3]								// widths
-	);
-	var elevationPainter = new SmoothElevationPainter(
-		ELEVATION_SET,			// type
-		3,				// elevation
-		4				// blend radius
-	);
-	createArea(placer, [terrainPainter, elevationPainter], null);
+for (let m = 0; m < numPlayers * split; ++m)
+{
+	log("Creating rivers between players...");
+	let angle = startAngle + (m + 0.5) * 2 * Math.PI / (numPlayers * split);
+	createArea(
+		new PathPlacer(
+			fractionToTiles(0.5 + 0.15 * Math.cos(angle)),
+			fractionToTiles(0.5 + 0.15 * Math.sin(angle)),
+			fractionToTiles(0.5 + 0.6 * Math.cos(angle)),
+			fractionToTiles(0.5 + 0.6 * Math.sin(angle)),
+			scaleByMapSize(14, 40),
+			0,
+			3 * scaleByMapSize(1, 3),
+			0.2,
+			0.05),
+		new SmoothElevationPainter(ELEVATION_SET, -4, 4),
+	    avoidClasses(clPlayer, 5));
+
+	log("Create path from the island to the center...");
+	angle = startAngle + m * 2 * Math.PI / (numPlayers * split);
+	createArea(
+		new PathPlacer(
+			fractionToTiles(0.5 + 0.05 * Math.cos(angle)),
+			fractionToTiles(0.5 + 0.05 * Math.sin(angle)),
+			fractionToTiles(0.5 + 0.49 * Math.cos(angle)),
+			fractionToTiles(0.5 + 0.49 * Math.sin(angle)),
+			scaleByMapSize(10, 40),
+			0,
+			3 * scaleByMapSize(1, 3),
+			0.2,
+			0.05),
+		new SmoothElevationPainter(ELEVATION_SET, 3, 4),
+		null);
 }
 
-var fx = fractionToTiles(0.5);
-var fz = fractionToTiles(0.5);
-ix = round(fx);
-iz = round(fz);
+log("Creating ring of land connecting players...");
+createArea(
+	new ClumpPlacer(mapArea * 0.15, 1, 1, 10, center, center),
+	new SmoothElevationPainter(ELEVATION_SET, 4, 4),
+	null);
 
-var placer = new ClumpPlacer(mapArea * 0.15, 1, 1, 10, ix, iz);
-var terrainPainter = new LayeredPainter(
-	[tShore, tWater, tWater, tWater],		// terrains
-	[1, 4, 2]		// widths
-);
-var elevationPainter = new SmoothElevationPainter(
-	ELEVATION_SET,			// type
-	4,				// elevation
-	4				// blend radius
-);
-createArea(placer, [terrainPainter, elevationPainter, unPaintClass(clWater)], null);
+log("Creating ring of water separating the central hill from the ring...");
+createArea(
+	new ClumpPlacer(mapArea * 0.09, 1, 1, 10, center, center),
+	new SmoothElevationPainter(ELEVATION_SET, -2, 3),
+	null);
 
-var fx = fractionToTiles(0.5);
-var fz = fractionToTiles(0.5);
-ix = round(fx);
-iz = round(fz);
+log("Creating central island...");
+createArea(
+	new ClumpPlacer(Math.pow(mapSize - 50, 2) * 0.09, 1, 1, 10, center, center),
+	new SmoothElevationPainter(ELEVATION_SET, 4, 3),
+	null);
 
-var lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 8))));
-
-var placer = new ClumpPlacer(mapArea * 0.09, 1, 1, 10, ix, iz);
-var terrainPainter = new LayeredPainter(
-	[tShore, tWater, tWater],		// terrains
-	[1, 3]								// widths
-);
-var elevationPainter = new SmoothElevationPainter(
-	ELEVATION_SET,			// type
-	-2,				// elevation
-	3				// blend radius
-);
-createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], null);
-
-var placer = new ClumpPlacer((mapSize - 50) * (mapSize - 50) * 0.09, 1, 1, 10, ix, iz);
-var terrainPainter = new LayeredPainter(
-	[tShore, tWater, tWater, tWater],		// terrains
-	[1, 4, 2]		// widths
-);
-var elevationPainter = new SmoothElevationPainter(
-	ELEVATION_SET,			// type
-	4,				// elevation
-	3				// blend radius
-);
-createArea(placer, [terrainPainter, elevationPainter, unPaintClass(clWater)], null);
-
-var placer = new ClumpPlacer(scaleByMapSize(6, 18)*scaleByMapSize(6, 18)*22, 1, 1, 10, ix, iz);
-var terrainPainter = new LayeredPainter(
-	[tMainTerrain, tMainTerrain],		// terrains
-	[1]		// widths
-);
-var elevationPainter = new SmoothElevationPainter(
-	ELEVATION_SET,			// type
-	20,				// elevation
-	8				// blend radius
-);
-createArea(placer, [terrainPainter, elevationPainter], null);
+log("Creating hill on the central island...");
+createArea(
+	new ClumpPlacer(Math.pow(scaleByMapSize(6, 18), 2) * 22, 1, 1, 10, center, center),
+	new SmoothElevationPainter(ELEVATION_SET, 20, 8),
+	null);
 
 paintTerrainBasedOnHeight(-6, 1, 1, tWater);
 paintTerrainBasedOnHeight(1, 2, 1, tShore);
-paintTerrainBasedOnHeight(2, 5, 1, tMainTerrain);
+paintTerrainBasedOnHeight(2, 21, 1, tMainTerrain);
 
 paintTileClassBasedOnHeight(-6, 0.5, 1, clWater);
-unPaintTileClassBasedOnHeight(0.5, 10, 1, clWater);
 
 for (var i = 0; i < numPlayers; i++)
 {
@@ -424,7 +374,8 @@ createFood
  avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 10)
 );
 
-var types = [oTree1, oTree2, oTree4, oTree3];	// some variation
-createStragglerTrees(types, avoidClasses(clWater, 5, clForest, 7, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6));
+createStragglerTrees(
+	[oTree1, oTree2, oTree4, oTree3],
+	avoidClasses(clWater, 5, clForest, 7, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6));
 
 ExportMap();
diff --git a/binaries/data/mods/public/maps/random/guadalquivir_river.js b/binaries/data/mods/public/maps/random/guadalquivir_river.js
index b7fe4cdc15..7b55b1c6b6 100644
--- a/binaries/data/mods/public/maps/random/guadalquivir_river.js
+++ b/binaries/data/mods/public/maps/random/guadalquivir_river.js
@@ -314,8 +314,9 @@ createFood
 RMS.SetProgress(85);
 
 log("Creating straggler trees...");
-var types = [oPoplar, oCarob, oApple];	// some variation
-createStragglerTrees(types, [avoidClasses(clForest, 1, clHill, 1, clPlayer, 9, clMetal, 6, clRock, 6, clRiver, 1), stayClasses(clLand, 7)]);
+createStragglerTrees(
+	[oPoplar, oCarob, oApple],
+	[avoidClasses(clForest, 1, clHill, 1, clPlayer, 9, clMetal, 6, clRock, 6, clRiver, 1), stayClasses(clLand, 7)]);
 
 setSkySet("cumulus");
 setWaterColor(0.2,0.312,0.522);
diff --git a/binaries/data/mods/public/maps/random/gulf_of_bothnia.js b/binaries/data/mods/public/maps/random/gulf_of_bothnia.js
index 49b5aeba48..92ea464005 100644
--- a/binaries/data/mods/public/maps/random/gulf_of_bothnia.js
+++ b/binaries/data/mods/public/maps/random/gulf_of_bothnia.js
@@ -23,7 +23,6 @@ if (random_terrain == 1)
 	var tShore = "alpine_shore_rocks_grass_50";
 	var tWater = "alpine_shore_rocks";
 
-	// gaia entities
 	var oPine = "gaia/flora_tree_pine";
 	var oBerryBush = "gaia/flora_bush_berry";
 	var oDeer = "gaia/fauna_deer";
@@ -33,7 +32,6 @@ if (random_terrain == 1)
 	var oStoneSmall = "gaia/geology_stone_alpine_a";
 	var oMetalLarge = "gaia/geology_metal_alpine_slabs";
 
-	// decorative props
 	var aGrass = "actor|props/flora/grass_soft_small_tall.xml";
 	var aGrassShort = "actor|props/flora/grass_soft_large.xml";
 	var aRockLarge = "actor|geology/stone_granite_med.xml";
@@ -59,7 +57,6 @@ else if (random_terrain == 2)
 	var tShore = "alpine_shore_rocks_icy";
 	var tWater = "alpine_shore_rocks";
 
-	// gaia entities
 	var oPine = "gaia/flora_tree_pine_w";
 	var oBerryBush = "gaia/flora_bush_berry";
 	var oDeer = "gaia/fauna_deer";
@@ -69,7 +66,6 @@ else if (random_terrain == 2)
 	var oStoneSmall = "gaia/geology_stone_alpine_a";
 	var oMetalLarge = "gaia/geology_metal_alpine_slabs";
 
-	// decorative props
 	var aGrass = "actor|props/flora/grass_soft_dry_small_tall.xml";
 	var aGrassShort = "actor|props/flora/grass_soft_dry_large.xml";
 	var aRockLarge = "actor|geology/stone_granite_med.xml";
@@ -95,7 +91,6 @@ else
 	var tShore = "polar_ice_snow";
 	var tWater = ["polar_ice_snow", "polar_ice"];
 
-	// gaia entities
 	var oPine = "gaia/flora_tree_pine_w";
 	var oBerryBush = "gaia/flora_bush_berry";
 	var oDeer = "gaia/fauna_deer";
@@ -105,7 +100,6 @@ else
 	var oStoneSmall = "gaia/geology_stone_alpine_a";
 	var oMetalLarge = "gaia/geology_metal_alpine_slabs";
 
-	// decorative props
 	var aGrass = "actor|props/flora/grass_soft_dry_small_tall.xml";
 	var aGrassShort = "actor|props/flora/grass_soft_dry_large.xml";
 	var aRockLarge = "actor|geology/stone_granite_med.xml";
@@ -134,20 +128,17 @@ var clBaseResource = createTileClass();
 initTerrain(tPrimary);
 
 var playerIDs = sortAllPlayers();
-
 var playerX = [];
 var playerZ = [];
-var playerAngle = [];
+var startAngle = -Math.PI / 6;
 
-var startAngle = -PI/6;
-for (var i = 0; i < numPlayers; i++)
+for (let i = 0; i < numPlayers; ++i)
 {
-	if (numPlayers == 1)
-		playerAngle[i] = startAngle + TWO_PI/3;
-	else
-		playerAngle[i] = startAngle + i*TWO_PI/(numPlayers-1)*2/3;
-	playerX[i] = 0.5 + 0.35*cos(playerAngle[i]);
-	playerZ[i] = 0.5 + 0.35*sin(playerAngle[i]);
+	let playerAngle = startAngle + 2/3 * Math.PI *
+		(numPlayers == 1 ? 1 : 2 * i / (numPlayers - 1));
+
+	playerX[i] = 0.5 + 0.35 * Math.cos(playerAngle);
+	playerZ[i] = 0.5 + 0.35 * Math.sin(playerAngle);
 }
 
 for (var i = 0; i < numPlayers; i++)
@@ -229,80 +220,33 @@ for (var i = 0; i < numPlayers; i++)
 
 RMS.SetProgress(20);
 
-//create the gulf
+log("Creating the gulf...");
+var seaHeight = random_terrain == 3 ? 0 : -3;
 
-if (random_terrain == 3)
-{
-	var seaHeight = 0;
-}
-else
-{
-	var seaHeight = -3;
-}
+var lSize = Math.pow(scaleByMapSize(1, 6), 1/8);
+var gulfLocations = [
+	[200, Math.round(fractionToTiles(0.5)), 0.17],
+	[120, Math.round(fractionToTiles(0.3)), 0.18 * lSize],
+	[100, 1, 0.19 * lSize]
+];
 
-//create the upper part
-
-var fx = fractionToTiles(0.5);
-var fz = fractionToTiles(0.5);
-ix = round(fx);
-iz = round(fz);
-
-var lSize = 1;
-
-var placer = new ChainPlacer(2, floor(scaleByMapSize(5, 16)), floor(scaleByMapSize(35, 200)), 1, ix, iz, 0, [floor(mapSize * 0.17 * lSize)]);
-var terrainPainter = new LayeredPainter(
-	[tPrimary, tPrimary, tPrimary, tPrimary],		// terrains
-	[1, 4, 2]		// widths
-);
-
-var elevationPainter = new SmoothElevationPainter(
-	ELEVATION_SET,			// type
-	seaHeight,				// elevation
-	4				// blend radius
-);
-createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer,scaleByMapSize(20,28)));
-
-//the middle part
-
-var fx = fractionToTiles(0.5);
-var fz = fractionToTiles(0.3);
-ix = round(fx);
-iz = round(fz);
-
-var lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 6))));
-
-var placer = new ChainPlacer(2, floor(scaleByMapSize(5, 16)), floor(scaleByMapSize(35, 120)), 1, ix, iz, 0, [floor(mapSize * 0.18 * lSize)]);
-var terrainPainter = new LayeredPainter(
-	[tPrimary, tPrimary, tPrimary, tPrimary],		// terrains
-	[1, 4, 2]		// widths
-);
-var elevationPainter = new SmoothElevationPainter(
-	ELEVATION_SET,			// type
-	seaHeight,				// elevation
-	4				// blend radius
-);
-createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer,scaleByMapSize(20,28)));
-
-//the lower part
-
-var fx = fractionToTiles(0.5);
-var fz = 0;
-ix = round(fx);
-iz = round(fz)+1;
-
-var lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 6))));
-
-var placer = new ChainPlacer(2, floor(scaleByMapSize(5, 16)), floor(scaleByMapSize(35, 100)), 1, ix, iz, 0, [floor(mapSize * 0.19 * lSize)]);
-var terrainPainter = new LayeredPainter(
-	[tPrimary, tPrimary, tPrimary, tPrimary],		// terrains
-	[1, 4, 2]		// widths
-);
-var elevationPainter = new SmoothElevationPainter(
-	ELEVATION_SET,			// type
-	seaHeight,				// elevation
-	4				// blend radius
-);
-createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer,scaleByMapSize(20,28)));
+for (let [numCircles, z, firstRadius] of gulfLocations)
+	createArea(
+		new ChainPlacer(
+			2,
+			Math.floor(scaleByMapSize(5, 16)),
+			Math.floor(scaleByMapSize(35, numCircles)),
+			1,
+			Math.round(fractionToTiles(0.5)),
+			z,
+			0,
+			[Math.floor(mapSize * firstRadius)]),
+		[
+			new LayeredPainter([tPrimary, tPrimary, tPrimary, tPrimary], [1, 4, 2]),
+			new SmoothElevationPainter(ELEVATION_SET, seaHeight, 4),
+			paintClass(clWater)
+		],
+		avoidClasses(clPlayer,scaleByMapSize(20, 28)));
 
 if (random_terrain == 3)
 {
@@ -326,7 +270,7 @@ createForests(
  [tPrimary, tForestFloor, tForestFloor, pForest, pForest],
  avoidClasses(clPlayer, 20, clForest, 16, clHill, 0, clWater, 2),
  clForest,
- 1.0);
+ 1);
 
 RMS.SetProgress(60);
 
@@ -367,27 +311,23 @@ createMines(
 
 RMS.SetProgress(70);
 
-var multiplier = 0;
-if (random_terrain !== 3) multiplier = 1;
-
-createDecoration
-(
- [[new SimpleObject(aRockMedium, 1,3, 0,1)],
-  [new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
-  [new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)],
-  [new SimpleObject(aGrass, 2,4, 0,1.8, -PI/8,PI/8), new SimpleObject(aGrassShort, 3,6, 1.2,2.5, -PI/8,PI/8)],
-  [new SimpleObject(aBushMedium, 1,2, 0,2), new SimpleObject(aBushSmall, 2,4, 0,2)]
- ],
- [
-  scaleByMapSize(16, 262),
-  scaleByMapSize(8, 131),
-  multiplier * scaleByMapSize(13, 200),
-  multiplier * scaleByMapSize(13, 200),
-  multiplier * scaleByMapSize(13, 200)
- ],
- avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0)
-);
-
+var multiplier = random_terrain == 3 ? 0 : 1;
+createDecoration(
+	[
+		[new SimpleObject(aRockMedium, 1, 3, 0, 1)],
+		[new SimpleObject(aRockLarge, 1, 2, 0, 1), new SimpleObject(aRockMedium, 1, 3, 0, 2)],
+		[new SimpleObject(aGrassShort, 1, 2, 0, 1)],
+		[new SimpleObject(aGrass, 2, 4, 0, 1.8), new SimpleObject(aGrassShort, 3, 6, 1.2, 2.5)],
+		[new SimpleObject(aBushMedium, 1, 2, 0, 2), new SimpleObject(aBushSmall, 2, 4, 0, 2)]
+	],
+	[
+		scaleByMapSize(16, 262),
+		scaleByMapSize(8, 131),
+		multiplier * scaleByMapSize(13, 200),
+		multiplier * scaleByMapSize(13, 200),
+		multiplier * scaleByMapSize(13, 200)
+	 ],
+	 avoidClasses(clWater, 0, clForest, 0, clPlayer, 5, clHill, 0, clBaseResource, 5));
 RMS.SetProgress(75);
 
 createFood
diff --git a/binaries/data/mods/public/maps/random/harbor.js b/binaries/data/mods/public/maps/random/harbor.js
index 04cca5c72d..beaa89dcec 100644
--- a/binaries/data/mods/public/maps/random/harbor.js
+++ b/binaries/data/mods/public/maps/random/harbor.js
@@ -253,7 +253,6 @@ ExportMap();
 
 function addCenterLake()
 {
-	let lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 6))));
 	let center = Math.round(fractionToTiles(0.5));
 
 	createArea(
@@ -265,8 +264,7 @@ function addCenterLake()
 			center,
 			center,
 			0,
-			[Math.floor(mapSize * 0.17 * lSize)]
-		),
+			[Math.floor(mapSize * 0.17 * Math.pow(scaleByMapSize(1, 6), 1/8))]),
 		[
 			new LayeredPainter(
 				[
diff --git a/binaries/data/mods/public/maps/random/hyrcanian_shores.js b/binaries/data/mods/public/maps/random/hyrcanian_shores.js
index 6c7f627671..6915c4100f 100644
--- a/binaries/data/mods/public/maps/random/hyrcanian_shores.js
+++ b/binaries/data/mods/public/maps/random/hyrcanian_shores.js
@@ -34,7 +34,6 @@ const aRockMedium = "actor|geology/stone_granite_med.xml";
 const aBushMedium = "actor|props/flora/bush_medit_me_lush.xml";
 const aBushSmall = "actor|props/flora/bush_medit_sm_lush.xml";
 
-// terrain + entity (for painting)
 const pForestD = [tGrassDForest + TERRAIN_SEPARATOR + oPoplar, tGrassDForest];
 const pForestP = [tGrassPForest + TERRAIN_SEPARATOR + oOak, tGrassPForest];
 
@@ -164,46 +163,34 @@ paintRiver({
 RMS.SetProgress(20);
 
 log("Creating fish...");
-
-num = scaleByMapSize(10, 20);
-for (var i=0; i < num; i++){
-group = new SimpleGroup(
-	[new SimpleObject(oFish, 2,3, 0,2)],
-	true, clFood
-);
-createObjectGroupsDeprecated(group, 0,
-	[stayClasses(clWater, 2), avoidClasses(clFood, 3)],
-	numPlayers, 50
-);
-}
-
+for (let i = 0; i < scaleByMapSize(10, 20); ++i)
+	createObjectGroupsDeprecated(
+		new SimpleGroup([new SimpleObject(oFish, 2, 3, 0, 2)], true, clFood),
+		0,
+		[stayClasses(clWater, 2), avoidClasses(clFood, 3)],
+		numPlayers,
+		50);
 RMS.SetProgress(25);
 
 log("Creating bumps...");
-placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1);
-painter = new SmoothElevationPainter(ELEVATION_MODIFY, 4, 3);
 createAreas(
-	placer,
-	painter,
+	new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1),
+	new SmoothElevationPainter(ELEVATION_MODIFY, 4, 3),
 	stayClasses(clHighlands, 1),
-	scaleByMapSize(300, 600)
-);
+	scaleByMapSize(300, 600));
 
 RMS.SetProgress(30);
 
 log("Creating hills...");
-placer = new ClumpPlacer(scaleByMapSize(20, 150), 0.2, 0.1, 1);
-var terrainPainter = new LayeredPainter(
-	[tCliff, tHill],		// terrains
-	[2]								// widths
-);
-var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 15, 2);
 createAreas(
-	placer,
-	[terrainPainter, elevationPainter, paintClass(clHill)],
+	new ClumpPlacer(scaleByMapSize(20, 150), 0.2, 0.1, 1),
+	[
+		new LayeredPainter([tCliff, tHill], [2]),
+		new SmoothElevationPainter(ELEVATION_SET, 15, 2),
+		paintClass(clHill)
+	],
 	avoidClasses(clSea, 5, clPlayer, 20, clWater, 5, clHill, 15, clHighlands, 5),
-	scaleByMapSize(1, 4) * numPlayers
-);
+	scaleByMapSize(1, 4) * numPlayers);
 
 RMS.SetProgress(35);
 
@@ -219,78 +206,56 @@ var numStragglers = totalTrees * (1.0 - P_FOREST);
 log("Creating mainland forests...");
 var types = [
 	[[tGrassDForest, tGrass, pForestD], [tGrassDForest, pForestD]]
-];	// some variation
-var size = numForest*1.3 / (scaleByMapSize(2,8) * numPlayers);
-var num = floor(0.7*size / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	placer = new ClumpPlacer(numForest / num, 0.1, 0.1, 1);
-	painter = new LayeredPainter(
-		types[i],		// terrains
-		[2]											// widths
-		);
+];
+var size = numForest * 1.3 / (scaleByMapSize(2,8) * numPlayers);
+var num = Math.floor(0.7 * size / types.length);
+for (let type of types)
 	createAreas(
-		placer,
-		[painter, paintClass(clForest)],
+		new ClumpPlacer(numForest / num, 0.1, 0.1, 1),
+		[
+			new LayeredPainter(type, [2]),
+			paintClass(clForest)
+		],
 		avoidClasses(clPlayer, 20, clWater, 3, clForest, 10, clHill, 0, clSea, 6, clBaseResource, 3),
-		num
-	);
-}
+		num);
 RMS.SetProgress(45);
 
 log("Creating highland forests...");
 var types = [
 	[[tGrassDForest, tGrass, pForestP], [tGrassDForest, pForestP]]
-];	// some variation
+];
 var size = numForest / (scaleByMapSize(2,8) * numPlayers);
 var num = floor(size / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	placer = new ClumpPlacer(numForest / num, 0.1, 0.1, 1);
-	painter = new LayeredPainter(
-		types[i],		// terrains
-		[2]											// widths
-		);
+for (let type of types)
 	createAreas(
-		placer,
-		[painter, paintClass(clForest)],
+		new ClumpPlacer(numForest / num, 0.1, 0.1, 1),
+		[
+			new LayeredPainter(type, [2]),
+			paintClass(clForest)
+		],
 		avoidClasses(clPlayer, 20, clWater, 3, clForest, 2, clHill, 0, clSea, 6, clFlatlands, 3),
-		num
-	);
-}
+		num);
 RMS.SetProgress(70);
 
 log("Creating dirt patches...");
-var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
-for (var i = 0; i < sizes.length; i++)
-{
-	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
-	painter = new LayeredPainter(
-		[[tGrass,tGrassA],[tGrassA,tGrassB], [tGrassB,tGrassC]], 		// terrains
-		[1,1]															// widths
-	);
+for (let size of [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)])
 	createAreas(
-		placer,
-		[painter, paintClass(clDirt)],
+		new ClumpPlacer(size, 0.3, 0.06, 0.5),
+		[
+			new LayeredPainter([[tGrass, tGrassA], [tGrassA, tGrassB], [tGrassB, tGrassC]], [1, 1]),
+			paintClass(clDirt)
+		],
 		avoidClasses(clWater, 1, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 4, clSea, 0),
-		scaleByMapSize(15, 45)
-	);
-}
+		scaleByMapSize(15, 45));
 RMS.SetProgress(75);
 
 log("Creating grass patches...");
-var sizes = [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)];
-for (var i = 0; i < sizes.length; i++)
-{
-	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
-	painter = new LayeredPainter([tGrassC, tGrassPatch], [2]);
+for (let size of [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)])
 	createAreas(
-		placer,
-		painter,
-		avoidClasses(clWater, 1, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 4, clSea, 0),
-		scaleByMapSize(15, 45)
-	);
-}
+		new ClumpPlacer(size, 0.3, 0.06, 0.5),
+		new LayeredPainter([tGrassC, tGrassPatch], [2]),
+		avoidClasses(clWater, 1, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 6, clSea, 0, clBaseResource, 6),
+		scaleByMapSize(15, 45));
 
 RMS.SetProgress(80);
 
@@ -381,19 +346,14 @@ createObjectGroupsDeprecated(group, 0,
 );
 
 log("Creating straggler trees...");
-var types = [oPoplar, oPalm, oApple];	// some variation
+var types = [oPoplar, oPalm, oApple];
 var num = floor(numStragglers / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	group = new SimpleGroup(
-		[new SimpleObject(types[i], 1,1, 0,3)],
-		true, clForest
-	);
-	createObjectGroupsDeprecated(group, 0,
+for (let type of types)
+	createObjectGroupsDeprecated(
+		new SimpleGroup([new SimpleObject(type, 1, 1, 0, 3)], true, clForest),
+		0,
 		avoidClasses(clWater, 1, clForest, 1, clHill, 1, clPlayer, 10, clMetal, 6, clRock, 6, clSea, 1, clHighlands, 25),
-		num
-	);
-}
+		num);
 
 log("Creating small grass tufts...");
 group = new SimpleGroup(
diff --git a/binaries/data/mods/public/maps/random/island_stronghold.js b/binaries/data/mods/public/maps/random/island_stronghold.js
index 7689371a46..c6fad7bb1f 100644
--- a/binaries/data/mods/public/maps/random/island_stronghold.js
+++ b/binaries/data/mods/public/maps/random/island_stronghold.js
@@ -63,28 +63,25 @@ InitMap();
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 
-let clPlayer = createTileClass();
-let clHill = createTileClass();
-let clForest = createTileClass();
-let clDirt = createTileClass();
-let clRock = createTileClass();
-let clMetal = createTileClass();
-let clFood = createTileClass();
-let clBaseResource = createTileClass();
-let clLand = createTileClass();
+const clPlayer = createTileClass();
+const clHill = createTileClass();
+const clForest = createTileClass();
+const clDirt = createTileClass();
+const clRock = createTileClass();
+const clMetal = createTileClass();
+const clFood = createTileClass();
+const clBaseResource = createTileClass();
+const clLand = createTileClass();
+
+const shoreRadius = 6;
+const landHeight = 3;
 
 initTerrain(tWater);
 
-// some constants
-let radius = scaleByMapSize(15, 25);
-
-let fx = fractionToTiles(0.5);
-let fz = fractionToTiles(0.5);
-
-let startAngle = randFloat(0, TWO_PI);
+var startAngle = randFloat(0, 2 * Math.PI);
 
 // Group players by team
-let teams = [];
+var teams = [];
 for (let i = 0; i < numPlayers; ++i)
 {
 	let team = getPlayerTeam(i);
@@ -113,14 +110,9 @@ for (let i = 0; i < numPlayers; ++i)
 }
 
 // Get number of used team IDs
-let numTeams = teams.filter(team => team).length;
-
-RMS.SetProgress(10);
-
-let shoreRadius = 6;
-let elevation = 3;
-let teamNo = 0;
+var numTeams = teams.filter(team => team).length;
 
+var teamNo = 0;
 for (let i = 0; i < teams.length; ++i)
 {
 	if (!teams[i])
@@ -140,18 +132,14 @@ for (let i = 0; i < teams.length; ++i)
 
 		addCivicCenterAreaToClass(ix, iz, clPlayer);
 
-		// create an island
-		let placer = new ChainPlacer(2, floor(scaleByMapSize(5, 11)), floor(scaleByMapSize(60, 250)), 1, ix, iz, 0, [floor(mapSize * 0.01)]);
-		let terrainPainter = new LayeredPainter(
-			[tMainTerrain, tMainTerrain, tMainTerrain],       // terrains
-			[1, shoreRadius]     // widths
-		);
-		let elevationPainter = new SmoothElevationPainter(
-			ELEVATION_SET,          // type
-			elevation,              // elevation
-			shoreRadius               // blend radius
-		);
-		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
+		createArea(
+			new ChainPlacer(2, Math.floor(scaleByMapSize(5, 11)), Math.floor(scaleByMapSize(60, 250)), 1, ix, iz, 0, [Math.floor(mapSize * 0.01)]),
+			[
+				new LayeredPainter([tMainTerrain, tMainTerrain, tMainTerrain], [1, shoreRadius]),
+				new SmoothElevationPainter(ELEVATION_SET, landHeight, shoreRadius),
+				paintClass(clLand)
+			],
+			null);
 
 		placeCivDefaultEntities(fx, fz, teams[i][p], { "iberWall": false });
 	}
@@ -235,9 +223,9 @@ for (let i = 0; i < teams.length; ++i)
 RMS.SetProgress(40);
 
 log("Creating expansion islands...");
-let landAreas = [];
-let playerConstraint = new AvoidTileClassConstraint(clPlayer, floor(scaleByMapSize(12, 16)));
-let landConstraint = new AvoidTileClassConstraint(clLand, floor(scaleByMapSize(12, 16)));
+var landAreas = [];
+var playerConstraint = new AvoidTileClassConstraint(clPlayer, Math.floor(scaleByMapSize(12, 16)));
+var landConstraint = new AvoidTileClassConstraint(clLand, Math.floor(scaleByMapSize(12, 16)));
 
 for (let x = 0; x < mapSize; ++x)
 	for (let z = 0; z < mapSize; ++z)
@@ -245,28 +233,22 @@ for (let x = 0; x < mapSize; ++x)
 			landAreas.push([x, z]);
 
 log("Creating big islands...");
-let chosenPoint;
-let landAreaLen;
 let numIslands = scaleByMapSize(4, 14);
 for (let i = 0; i < numIslands; ++i)
 {
-	landAreaLen = landAreas.length;
+	let landAreaLen = landAreas.length;
 	if (!landAreaLen)
 		break;
 
-	chosenPoint = pickRandom(landAreas);
+	let chosenPoint = pickRandom(landAreas);
 
-	// create big islands
-	let placer = new ChainPlacer(floor(scaleByMapSize(4, 8)), floor(scaleByMapSize(8, 14)), floor(scaleByMapSize(25, 60)), 0.07, chosenPoint[0], chosenPoint[1], scaleByMapSize(30, 70));
-	let terrainPainter = new LayeredPainter(
-		[tMainTerrain, tMainTerrain],		// terrains
-		[2]								// widths
-	);
-
-	let elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 6);
 	let newIsland = createAreas(
-		placer,
-		[terrainPainter, elevationPainter, paintClass(clLand)],
+		new ChainPlacer(Math.floor(scaleByMapSize(4, 8)), Math.floor(scaleByMapSize(8, 14)), Math.floor(scaleByMapSize(25, 60)), 0.07, chosenPoint[0], chosenPoint[1], scaleByMapSize(30, 70)),
+		[
+			new LayeredPainter([tMainTerrain, tMainTerrain], [2]),
+			new SmoothElevationPainter(ELEVATION_SET, landHeight, 6),
+			paintClass(clLand)
+		],
 		avoidClasses(clLand, 3, clPlayer, 3),
 		1, 1
 	);
@@ -293,25 +275,21 @@ log("Creating small islands...");
 numIslands = scaleByMapSize(6, 18) * scaleByMapSize(1, 3);
 for (let i = 0; i < numIslands; ++i)
 {
-	landAreaLen = landAreas.length;
+	let landAreaLen = landAreas.length;
 	if (!landAreaLen)
 		break;
 
-	chosenPoint = pickRandom(landAreas);
-
-	let placer = new ChainPlacer(floor(scaleByMapSize(4, 7)), floor(scaleByMapSize(7, 10)), floor(scaleByMapSize(16, 40)), 0.07, chosenPoint[0], chosenPoint[1], scaleByMapSize(22, 40));
-	let terrainPainter = new LayeredPainter(
-		[tMainTerrain, tMainTerrain],		// terrains
-		[2]								// widths
-	);
-
-	let elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 6);
+	let chosenPoint = pickRandom(landAreas);
 	let newIsland = createAreas(
-		placer,
-		[terrainPainter, elevationPainter, paintClass(clLand)],
+		new ChainPlacer(Math.floor(scaleByMapSize(4, 7)), Math.floor(scaleByMapSize(7, 10)), Math.floor(scaleByMapSize(16, 40)), 0.07, chosenPoint[0], chosenPoint[1], scaleByMapSize(22, 40)),
+		[
+			new LayeredPainter([tMainTerrain, tMainTerrain], [2]),
+			new SmoothElevationPainter(ELEVATION_SET, landHeight, 6),
+			paintClass(clLand)
+		],
 		avoidClasses(clLand, 3, clPlayer, 3),
-		1, 1
-	);
+		1,
+		1);
 
 	if (newIsland === undefined)
 		continue;
@@ -366,18 +344,17 @@ createForests(
  ...rBiomeTreeCount(1));
 
 log("Creating hills...");
-let placer = new ChainPlacer(1, floor(scaleByMapSize(4, 6)), floor(scaleByMapSize(16, 40)), 0.5);
-let painter = new LayeredPainter(
-	[tCliff, tHill],		// terrains
-	[2]								// widths
-);
-let elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 18, 2);
 createAreas(
-	placer,
-	[painter, elevationPainter, paintClass(clHill)],
+	new ChainPlacer(1, Math.floor(scaleByMapSize(4, 6)), Math.floor(scaleByMapSize(16, 40)), 0.5),
+	[
+		new LayeredPainter([tCliff, tHill], [2]),
+		new SmoothElevationPainter(ELEVATION_SET, 18, 2),
+		paintClass(clHill)
+	],
 	[avoidClasses(clBaseResource, 20, clHill, 15, clRock, 6, clMetal, 6), stayClasses(clLand, 0)],
 	scaleByMapSize(4, 13)
 );
+
 for (let i = 0; i < 3; ++i)
 	globalSmoothHeightmap();
 
@@ -419,37 +396,24 @@ if (currentBiome() == "desert")
 }
 
 log("Creating dirt patches...");
-let sizes = [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)];
 let numb = currentBiome() == "savanna" ? 3 : 1;
-
-for (let i = 0; i < sizes.length; ++i)
-{
-	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
-	painter = new LayeredPainter(
-		[[tMainTerrain,tTier1Terrain], [tTier1Terrain,tTier2Terrain], [tTier2Terrain,tTier3Terrain]],		// terrains
-		[1, 1]															// widths
-	);
+for (let size of [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)])
 	createAreas(
-		placer,
-		[painter, paintClass(clDirt)],
+		new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
+		[
+			new LayeredPainter([[tMainTerrain, tTier1Terrain], [tTier1Terrain, tTier2Terrain], [tTier2Terrain, tTier3Terrain]], [1, 1]),
+			paintClass(clDirt)
+		],
 		[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 0), stayClasses(clLand, 4)],
-		numb*scaleByMapSize(15, 45)
-	);
-}
+		numb*scaleByMapSize(15, 45));
 
 log("Creating grass patches...");
-sizes = [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)];
-for (let i = 0; i < sizes.length; ++i)
-{
-	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
-	painter = new TerrainPainter(tTier4Terrain);
+for (let size of [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)])
 	createAreas(
-		placer,
-		painter,
+		new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
+		new TerrainPainter(tTier4Terrain),
 		[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 0), stayClasses(clLand, 4)],
-		numb * scaleByMapSize(15, 45)
-	);
-}
+		numb * scaleByMapSize(15, 45));
 
 log("Creating small decorative rocks...");
 let group = new SimpleGroup(
@@ -513,8 +477,6 @@ createObjectGroupsDeprecated(group, 0,
 	scaleByMapSize(10, 20), 100
 );
 
-placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius, [stayClasses(clLand, 5)]);
-
 log("Creating small grass tufts...");
 let planetm = currentBiome() == "tropic" ? 8 : 1;
 group = new SimpleGroup(
diff --git a/binaries/data/mods/public/maps/random/islands.js b/binaries/data/mods/public/maps/random/islands.js
index f903136b73..df0f655dbb 100644
--- a/binaries/data/mods/public/maps/random/islands.js
+++ b/binaries/data/mods/public/maps/random/islands.js
@@ -172,8 +172,7 @@ var chosenPoint;
 var landAreaLen;
 
 log("Creating big islands...");
-var numIslands = scaleByMapSize(4, 14);
-for (var i = 0; i < numIslands; ++i)
+for (let i = 0; i < scaleByMapSize(4, 14); ++i)
 {
 	landAreaLen = landAreas.length;
 	if (!landAreaLen)
@@ -181,26 +180,30 @@ for (var i = 0; i < numIslands; ++i)
 
 	chosenPoint = pickRandom(landAreas);
 
-	// create big islands
-	placer = new ChainPlacer(floor(scaleByMapSize(4, 8)), floor(scaleByMapSize(8, 14)), floor(scaleByMapSize(25, 60)), 0.07, chosenPoint[0], chosenPoint[1], scaleByMapSize(30,70));
-	//placer = new ClumpPlacer(floor(hillSize*randFloat(0.9,2.1)), 0.80, 0.1, 0.07, chosenPoint[0], chosenPoint[1]);
-	terrainPainter = new LayeredPainter(
-		[tMainTerrain, tMainTerrain],		// terrains
-		[2]								// widths
-	);
-	elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 6);
 	var newIsland = createAreas(
-		placer,
-		[terrainPainter, elevationPainter, paintClass(clLand)],
+		new ChainPlacer(
+			Math.floor(scaleByMapSize(4, 8)),
+			Math.floor(scaleByMapSize(8, 14)),
+			Math.floor(scaleByMapSize(25, 60)),
+			0.07,
+			chosenPoint[0],
+			chosenPoint[1],
+			scaleByMapSize(30, 70)),
+		[
+			new LayeredPainter([tMainTerrain, tMainTerrain], [2]),
+			new SmoothElevationPainter(ELEVATION_SET, 3, 6),
+			paintClass(clLand)
+		],
 		avoidClasses(clLand, 3, clPlayer, 3),
-		1, 1
-	);
+		1,
+		1);
+
 	if (newIsland && newIsland.length)
 	{
 		var n = 0;
-		for (var j = 0; j < landAreaLen; ++j)
+		for (var j = 0; j < landAreas.length; ++j)
 		{
-			var x = landAreas[j][0], z = landAreas[j][1];
+			let [x, z] = landAreas[j];
 			if (playerConstraint.allows(x, z) && landConstraint.allows(x, z))
 				landAreas[n++] = landAreas[j];
 		}
@@ -212,8 +215,7 @@ playerConstraint = new AvoidTileClassConstraint(clPlayer, floor(scaleByMapSize(9
 landConstraint = new AvoidTileClassConstraint(clLand, floor(scaleByMapSize(9,12)));
 
 log("Creating small islands...");
-numIslands = scaleByMapSize(6, 18) * scaleByMapSize(1,3);
-for (var i = 0; i < numIslands; ++i)
+for (let i = 0; i < 6 * Math.pow(scaleByMapSize(1, 3), 2); ++i)
 {
 	landAreaLen = landAreas.length;
 	if (!landAreaLen)
@@ -221,24 +223,30 @@ for (var i = 0; i < numIslands; ++i)
 
 	chosenPoint = pickRandom(landAreas);
 
-	placer = new ChainPlacer(floor(scaleByMapSize(4, 7)), floor(scaleByMapSize(7, 10)), floor(scaleByMapSize(16, 40)), 0.07, chosenPoint[0], chosenPoint[1], scaleByMapSize(22,40));
-	terrainPainter = new LayeredPainter(
-		[tMainTerrain, tMainTerrain],		// terrains
-		[2]								// widths
-	);
-	elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 6);
 	createAreas(
-		placer,
-		[terrainPainter, elevationPainter, paintClass(clLand)],
+		new ChainPlacer(
+			Math.floor(scaleByMapSize(4, 7)),
+			Math.floor(scaleByMapSize(7, 10)),
+			Math.floor(scaleByMapSize(16, 40)),
+			0.07,
+			chosenPoint[0],
+			chosenPoint[1],
+			scaleByMapSize(22, 40)),
+		[
+			new LayeredPainter([tMainTerrain, tMainTerrain], [2]),
+			new SmoothElevationPainter(ELEVATION_SET, 3, 6),
+			paintClass(clLand)
+		],
 		avoidClasses(clLand, 3, clPlayer, 3),
-		1, 1
-	);
+		1,
+		1);
+
 	if (newIsland !== undefined)
 	{
 		var temp = [];
 		for (var j = 0; j < landAreaLen; ++j)
 		{
-			var x = landAreas[j][0], z = landAreas[j][1];
+			let [x, z] = landAreas[j];
 			if (playerConstraint.allows(x, z) && landConstraint.allows(x, z))
 					temp.push([x, z]);
 		}
@@ -262,28 +270,22 @@ for (var i = 0; i < numPlayers; i++)
 }
 
 log("Creating bumps...");
-placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1);
-painter = new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2);
 createAreas(
-	placer,
-	painter,
+	new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1),
+	new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2),
 	[avoidClasses(clPlayer, 0), stayClasses(clLand, 3)],
-	scaleByMapSize(20, 100)
-);
+	scaleByMapSize(20, 100));
 
 log("Creating hills...");
-placer = new ChainPlacer(1, floor(scaleByMapSize(4, 6)), floor(scaleByMapSize(16, 40)), 0.5);
-terrainPainter = new LayeredPainter(
-	[tCliff, tHill],		// terrains
-	[2]								// widths
-);
-elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 18, 2);
 createAreas(
-	placer,
-	[terrainPainter, elevationPainter, paintClass(clHill)],
+	new ChainPlacer(1, Math.floor(scaleByMapSize(4, 6)), Math.floor(scaleByMapSize(16, 40)), 0.5),
+	[
+		new LayeredPainter([tCliff, tHill], [2]),
+		new SmoothElevationPainter(ELEVATION_SET, 18, 2),
+		paintClass(clHill)
+	],
 	[avoidClasses(clPlayer, 2, clHill, 15), stayClasses(clLand, 0)],
-	scaleByMapSize(4, 13)
-);
+	scaleByMapSize(4, 13));
 
 // calculate desired number of trees for map (based on size)
 if (currentBiome() == "savanna")
@@ -312,66 +314,48 @@ log("Creating forests...");
 var types = [
 	[[tForestFloor2, tMainTerrain, pForest1], [tForestFloor2, pForest1]],
 	[[tForestFloor1, tMainTerrain, pForest2], [tForestFloor1, pForest2]]
-];	// some variation
+];
 
 if (currentBiome() != "savanna")
 {
 	var size = numForest / (scaleByMapSize(3,6) * numPlayers);
 	var num = floor(size / types.length);
-	for (var i = 0; i < types.length; ++i)
-	{
-		placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), numForest / (num * floor(scaleByMapSize(2,5))), 0.5);
-		painter = new LayeredPainter(
-			types[i],		// terrains
-			[2]											// widths
-			);
+	for (let type of types)
 		createAreas(
-			placer,
-			[painter, paintClass(clForest)],
+			new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), numForest / (num * Math.floor(scaleByMapSize(2, 5))), 0.5),
+			[
+				new LayeredPainter(type, [2]),
+				paintClass(clForest)
+			],
 			[avoidClasses(clPlayer, 0, clForest, 10, clHill, 0), stayClasses(clLand, 6)],
-			num
-		);
-	}
+			num);
 }
 
 RMS.SetProgress(50);
 log("Creating dirt patches...");
-var sizes = [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)];
-var numb = 1;
-if (currentBiome() == "savanna")
-	numb = 3;
-for (var i = 0; i < sizes.length; i++)
-{
-	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
-	painter = new LayeredPainter(
-		[[tMainTerrain,tTier1Terrain],[tTier1Terrain,tTier2Terrain], [tTier2Terrain,tTier3Terrain]], 		// terrains
-		[1,1]															// widths
-	);
+var numberOfPatches = scaleByMapSize(15, 45) * (currentBiome() == "savanna" ? 3 : 1);
+for (let size of [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)])
 	createAreas(
-		placer,
-		[painter, paintClass(clDirt)],
+		new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
+		[
+			new LayeredPainter([[tMainTerrain, tTier1Terrain], [tTier1Terrain, tTier2Terrain], [tTier2Terrain, tTier3Terrain]], [1, 1]),
+			paintClass(clDirt)
+		],
 		[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 0), stayClasses(clLand, 6)],
-		numb*scaleByMapSize(15, 45)
-	);
-}
+		numberOfPatches);
 
 log("Creating grass patches...");
-var sizes = [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)];
-for (var i = 0; i < sizes.length; i++)
-{
-	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
-	painter = new TerrainPainter(tTier4Terrain);
+for (let size of [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)])
 	createAreas(
-		placer,
-		painter,
+		new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
+		new TerrainPainter(tTier4Terrain),
 		[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 0), stayClasses(clLand, 6)],
-		numb*scaleByMapSize(15, 45)
-	);
-}
+		numberOfPatches);
+
 RMS.SetProgress(55);
 
 log("Creating stone mines...");
-group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
+var group = new SimpleGroup([new SimpleObject(oStoneSmall, 0, 2, 0, 4), new SimpleObject(oStoneLarge, 1, 1, 0, 4)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 0, clRock, 10, clHill, 1), stayClasses(clLand, 5)],
 	scaleByMapSize(4,16), 100
@@ -462,19 +446,14 @@ createObjectGroupsDeprecated(group, 0,
 RMS.SetProgress(85);
 
 log("Creating straggler trees...");
-var types = [oTree1, oTree2, oTree4, oTree3];	// some variation
+var types = [oTree1, oTree2, oTree4, oTree3];
 var num = floor(numStragglers / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	group = new SimpleGroup(
-		[new SimpleObject(types[i], 1,1, 0,3)],
-		true, clForest
-	);
-	createObjectGroupsDeprecated(group, 0,
+for (let type of types)
+	createObjectGroupsDeprecated(
+		new SimpleGroup([new SimpleObject(type, 1, 1, 0, 3)], true, clForest),
+		0,
 		[avoidClasses(clForest, 1, clHill, 1, clPlayer, 0, clMetal, 6, clRock, 6), stayClasses(clLand, 6)],
-		num
-	);
-}
+		num);
 
 var planetm = 1;
 if (currentBiome() == "tropic")
diff --git a/binaries/data/mods/public/maps/random/kerala.js b/binaries/data/mods/public/maps/random/kerala.js
index 39243cfb6d..5b183f251d 100644
--- a/binaries/data/mods/public/maps/random/kerala.js
+++ b/binaries/data/mods/public/maps/random/kerala.js
@@ -156,27 +156,21 @@ paintRiver({
 });
 
 log("Creating shores...");
-for (var i = 0; i < scaleByMapSize(20,120); i++)
-{
-	placer = new ChainPlacer(
-		1,
-		Math.floor(scaleByMapSize(4, 6)),
-		Math.floor(scaleByMapSize(16, 30)),
-		1,
-		randIntExclusive(0.28 * mapSize, 0.34 * mapSize),
-		randIntExclusive(0.1 * mapSize, 0.9 * mapSize));
-
-	var terrainPainter = new LayeredPainter(
-		[tGrass, tGrass],		// terrains
-		[2]								// widths
-	);
-	var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 3);
+for (let i = 0; i < scaleByMapSize(20, 120); ++i)
 	createArea(
-		placer,
-		[terrainPainter, elevationPainter, unPaintClass(clWater)],
-		null
-	);
-}
+		new ChainPlacer(
+			1,
+			Math.floor(scaleByMapSize(4, 6)),
+			Math.floor(scaleByMapSize(16, 30)),
+			1,
+			randIntExclusive(0.28 * mapSize, 0.34 * mapSize),
+			randIntExclusive(0.1 * mapSize, 0.9 * mapSize)),
+		[
+			new LayeredPainter([tGrass, tGrass], [2]),
+			new SmoothElevationPainter(ELEVATION_SET, 3, 3),
+			unPaintClass(clWater)
+		],
+		null);
 
 paintTerrainBasedOnHeight(-6, 1, 1, tWater);
 paintTerrainBasedOnHeight(1, 2.8, 1, tShoreBlend);
@@ -186,21 +180,17 @@ paintTileClassBasedOnHeight(-6, 0.5, 1, clWater);
 RMS.SetProgress(45);
 
 log("Creating hills...");
-placer = new ChainPlacer(1, floor(scaleByMapSize(4, 6)), floor(scaleByMapSize(16, 40)), 0.1);
-var terrainPainter = new LayeredPainter(
-	[tCliff, tGrass],		// terrains
-	[3]								// widths
-);
-var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 25, 3);
 createAreas(
-	placer,
-	[terrainPainter, elevationPainter, paintClass(clHill)],
+	new ChainPlacer(1, Math.floor(scaleByMapSize(4, 6)), Math.floor(scaleByMapSize(16, 40)), 0.1),
+	[
+		new LayeredPainter([tCliff, tGrass], [3]),
+		new SmoothElevationPainter(ELEVATION_SET, 25, 3),
+		paintClass(clHill)
+	],
 	[avoidClasses(clPlayer, 20, clHill, 5, clWater, 2, clBaseResource, 2), stayClasses(clMountains, 0)],
-	scaleByMapSize(5, 40) * numPlayers
-);
+	scaleByMapSize(5, 40) * numPlayers);
 
 // calculate desired number of trees for map (based on size)
-
 var MIN_TREES = 1000;
 var MAX_TREES = 6000;
 var P_FOREST = 0.7;
@@ -213,62 +203,48 @@ log("Creating forests...");
 var types = [
 	[[tGrass, tGrass, tGrass, tGrass, pForestD], [tGrass, tGrass, tGrass, pForestD]],
 	[[tGrass, tGrass, tGrass, tGrass, pForestP], [tGrass, tGrass, tGrass, pForestP]]
-];	// some variation
-
+];
 var size = numForest / (scaleByMapSize(3,6) * numPlayers);
-
 var num = floor(size / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), numForest / (num * floor(scaleByMapSize(2,4))), 0.5);
-	painter = new LayeredPainter(
-		types[i],		// terrains
-		[2]											// widths
-		);
+for (let type of types)
 	createAreas(
-		placer,
-		[painter, paintClass(clForest)],
+		new ChainPlacer(
+			1,
+			Math.floor(scaleByMapSize(3, 5)),
+			numForest / (num * Math.floor(scaleByMapSize(2, 4))),
+			0.5),
+		[
+			new LayeredPainter(type, [2]),
+			paintClass(clForest)
+		],
 		avoidClasses(clPlayer, 20, clForest, 10, clHill, 0, clWater, 8),
-		num
-	);
-}
+		num);
 
 RMS.SetProgress(70);
 
 log("Creating grass patches...");
-var sizes = [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)];
-for (var i = 0; i < sizes.length; i++)
-{
-	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
-	painter = new LayeredPainter(
-		[tGrassC,tGrassA,tGrassB], 		// terrains
-		[2,1]															// widths
-	);
+for (let size of [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)])
 	createAreas(
-		placer,
-		[painter, paintClass(clDirt)],
+		new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
+		[
+			new LayeredPainter([tGrassC, tGrassA, tGrassB], [2, 1]),
+			paintClass(clDirt)
+		],
 		avoidClasses(clWater, 8, clForest, 0, clHill, 0, clPlayer, 12, clDirt, 16),
-		scaleByMapSize(20, 80)
-	);
-}
-var sizes = [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)];
-for (var i = 0; i < sizes.length; i++)
-{
-	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
-	painter = new LayeredPainter(
-		[tPlants,tPlants], 		// terrains
-		[1]															// widths
-	);
+		scaleByMapSize(20, 80));
+
+for (let size of [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)])
 	createAreas(
-		placer,
-		[painter, paintClass(clDirt)],
+		new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
+		[
+			new LayeredPainter([tPlants, tPlants], [1]),
+			paintClass(clDirt)
+		],
 		avoidClasses(clWater, 8, clForest, 0, clHill, 0, clPlayer, 12, clDirt, 16),
-		scaleByMapSize(20, 80)
-	);
-}
+		scaleByMapSize(20, 80));
 
 log("Creating stone mines...");
-group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
+var group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clRock, 10, clHill, 1),
 	scaleByMapSize(4,16), 100
@@ -344,19 +320,14 @@ createObjectGroupsDeprecated(group, 0,
 RMS.SetProgress(95);
 
 log("Creating straggler trees...");
-var types = [oTree, oPalm];	// some variation
+var types = [oTree, oPalm];
 var num = floor(numStragglers / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	group = new SimpleGroup(
-		[new SimpleObject(types[i], 1,1, 0,3)],
-		true, clForest
-	);
-	createObjectGroupsDeprecated(group, 0,
+for (let type of types)
+	createObjectGroupsDeprecated(
+		new SimpleGroup([new SimpleObject(type, 1, 1, 0, 3)], true, clForest),
+		0,
 		avoidClasses(clWater, 5, clForest, 1, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6),
-		num
-	);
-}
+		num);
 
 log("Creating deer...");
 group = new SimpleGroup(
diff --git a/binaries/data/mods/public/maps/random/lake.js b/binaries/data/mods/public/maps/random/lake.js
index 517f0555ba..624bc17cf6 100644
--- a/binaries/data/mods/public/maps/random/lake.js
+++ b/binaries/data/mods/public/maps/random/lake.js
@@ -131,40 +131,33 @@ for (var i = 0; i < numPlayers; i++)
 
 RMS.SetProgress(20);
 
-//create the lake
-var fx = fractionToTiles(0.5);
-var fz = fractionToTiles(0.5);
-ix = round(fx);
-iz = round(fz);
-
-const lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 6))));
-
-var placer = new ChainPlacer(2, floor(scaleByMapSize(5, 16)), floor(scaleByMapSize(35, 200)), 1, ix, iz, 0, [floor(mapSize * 0.17 * lSize)]);
-var terrainPainter = new LayeredPainter(
-	[tShore, tWater, tWater, tWater],		// terrains
-	[1, 4, 2]		// widths
-);
-var elevationPainter = new SmoothElevationPainter(
-	ELEVATION_SET,			// type
-	-3,				// elevation
-	4				// blend radius
-);
-createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 20));
+log("Creating the lake...")
+createArea(
+	new ChainPlacer(
+		2,
+		Math.floor(scaleByMapSize(5, 16)),
+		Math.floor(scaleByMapSize(35, 200)),
+		1,
+		Math.round(fractionToTiles(0.5)),
+		Math.round(fractionToTiles(0.5)),
+		0,
+		[Math.floor(mapSize * 0.17 * Math.pow(scaleByMapSize(1, 6), 1/8))]),
+	[
+		new SmoothElevationPainter(ELEVATION_SET, -3, 4),
+		paintClass(clWater)
+	],
+	avoidClasses(clPlayer, 20));
 
 log("Creating more shore jaggedness...");
-
-placer = new ChainPlacer(2, floor(scaleByMapSize(4, 6)), 3, 1);
-terrainPainter = new LayeredPainter(
-	[tCliff, tHill],		// terrains
-	[2]								// widths
-);
-elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 4);
 createAreas(
-	placer,
-	[terrainPainter, elevationPainter, unPaintClass(clWater)],
+	new ChainPlacer(2, Math.floor(scaleByMapSize(4, 6)), 3, 1),
+	[
+		new LayeredPainter([tCliff, tHill], [2]),
+		unPaintClass(clWater)
+	],
 	borderClasses(clWater, 4, 7),
-	scaleByMapSize(12, 130) * 2, 150
-);
+	scaleByMapSize(12, 130) * 2,
+	150);
 
 paintTerrainBasedOnHeight(2.4, 3.4, 3, tMainTerrain);
 paintTerrainBasedOnHeight(1, 2.4, 0, tShore);
@@ -300,8 +293,10 @@ createFood
 
 RMS.SetProgress(85);
 
-var types = [oTree1, oTree2, oTree4, oTree3];	// some variation
-createStragglerTrees(types, avoidClasses(clWater, 5, clForest, 7, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6));
+createStragglerTrees(
+	[oTree1, oTree2, oTree4, oTree3],
+	avoidClasses(clWater, 5, clForest, 7, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6));
+
 setWaterWaviness(4.0);
 setWaterType("lake");
 
diff --git a/binaries/data/mods/public/maps/random/lorraine_plain.js b/binaries/data/mods/public/maps/random/lorraine_plain.js
index 0bf91d427d..cd208512f8 100644
--- a/binaries/data/mods/public/maps/random/lorraine_plain.js
+++ b/binaries/data/mods/public/maps/random/lorraine_plain.js
@@ -52,6 +52,7 @@ var clShallow = createTileClass();
 
 var playerIDs = primeSortAllPlayers();
 var playerPos = placePlayersRiver();
+var waterHeight = -4;
 
 var playerX = [];
 var playerZ = [];
@@ -142,73 +143,105 @@ for (var i = 0; i < numPlayers; i++)
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 }
 
-log("Creating the main river");
-var tang = randFloat(0, TWO_PI);
-var placer = new PathPlacer(1, fractionToTiles(0.5), fractionToTiles(0.99), fractionToTiles(0.5), scaleByMapSize(10,20), 0.5, 3*(scaleByMapSize(1,4)), 0.1, 0.01);
-var terrainPainter = new LayeredPainter(
-	[tShore, tWater, tWater],		// terrains
-	[1, 3]								// widths
-);
-var elevationPainter = new SmoothElevationPainter(
-	ELEVATION_SET,			// type
-	-4,				// elevation
-	4				// blend radius
-);
-createArea(placer, [terrainPainter, elevationPainter], avoidClasses(clPlayer, 4));
+log("Creating the main river...");
+var river1 = [1, fractionToTiles(0.5)];
+var river2 = [fractionToTiles(0.99), fractionToTiles(0.5)];
+createArea(
+	new PathPlacer(...river1, ...river2, scaleByMapSize(10, 20), 0.5, 3 * scaleByMapSize(1, 4), 0.1, 0.01),
+	new SmoothElevationPainter(ELEVATION_SET, waterHeight, 4),
+	avoidClasses(clPlayer, 4));
 
-placer = new ClumpPlacer(floor(PI*scaleByMapSize(10,20)*scaleByMapSize(10,20)/4), 0.95, 0.6, 10, 1, fractionToTiles(0.5));
-var painter = new LayeredPainter([tWater, tWater], [1]);
-var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -4, 2);
-createArea(placer, [painter, elevationPainter], avoidClasses(clPlayer, 8));
-
-placer = new ClumpPlacer(floor(PI*scaleByMapSize(10,20)*scaleByMapSize(10,20)/4), 0.95, 0.6, 10, fractionToTiles(0.99), fractionToTiles(0.5));
-var painter = new LayeredPainter([tWater, tWater], [1]);
-var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -4, 2);
-createArea(placer, [painter, elevationPainter], avoidClasses(clPlayer, 8));
-
-log("Creating the shallows of the main river");
+log("Creating small puddles at the map border to ensure players being separated...");
+for (let [fx, fz] of [river1, river2])
+	createArea(
+		new ClumpPlacer(Math.floor(Math.PI * Math.pow(scaleByMapSize(5, 10), 2)), 0.95, 0.6, 10, fx, fz),
+		new SmoothElevationPainter(ELEVATION_SET, waterHeight, 2),
+		avoidClasses(clPlayer, 8));
 
+log("Creating the shallows of the main river...");
 for (let i = 0; i <= randIntInclusive(3, scaleByMapSize(4, 6)); ++i)
 {
-	var cLocation = randFloat(0.15,0.85);
-	passageMaker(floor(fractionToTiles(cLocation)), floor(fractionToTiles(0.35)), floor(fractionToTiles(cLocation)), floor(fractionToTiles(0.65)), scaleByMapSize(4,8), -2, -2, 2, clShallow, undefined, -4);
+	let cLocation = Math.floor(fractionToTiles(randFloat(0.15, 0.85)));
+	passageMaker(
+		cLocation,
+		Math.floor(fractionToTiles(0.35)),
+		cLocation,
+		Math.floor(fractionToTiles(0.65)),
+		scaleByMapSize(4, 8),
+		-2,
+		-2,
+		2,
+		clShallow,
+		undefined,
+		waterHeight);
 }
 
-log("Creating tributaries");
+log("Creating tributaries...");
+var riverWidth = scaleByMapSize(10, 20);
 for (let i = 0; i <= randIntInclusive(8, scaleByMapSize(12, 20)); ++i)
 {
+	log("Determining tributary destination...");
 	let cLocation = randFloat(0.05, 0.95);
-
 	let sign = randBool() ? 1 : -1;
 	let tang = sign * PI * randFloat(0.2, 0.8);
 	let cDistance = sign * 0.05;
 
-	var point = getTIPIADBON([fractionToTiles(cLocation), fractionToTiles(0.5 + cDistance)], [fractionToTiles(cLocation), fractionToTiles(0.5 - cDistance)], [-6, -1.5], 0.5, 5, 0.01);
-	if (point !== undefined)
-	{
-		var placer = new PathPlacer(floor(point[0]), floor(point[1]), floor(fractionToTiles(0.5 + 0.49*cos(tang))), floor(fractionToTiles(0.5 + 0.49*sin(tang))), scaleByMapSize(10,20), 0.4, 3*(scaleByMapSize(1,4)), 0.1, 0.05);
-		var terrainPainter = new LayeredPainter(
-			[tShore, tWater, tWater],		// terrains
-			[1, 3]								// widths
-		);
-		var elevationPainter = new SmoothElevationPainter(
-			ELEVATION_SET,			// type
-			-4,				// elevation
-			4				// blend radius
-		);
-		var success = createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 3, clWater, 3, clShallow, 2));
-		if (success !== undefined)
-		{
-			placer = new ClumpPlacer(floor(PI*scaleByMapSize(10,20)*scaleByMapSize(10,20)/4), 0.95, 0.6, 10, fractionToTiles(0.5 + 0.49*cos(tang)), fractionToTiles(0.5 + 0.49*sin(tang)));
-			var painter = new LayeredPainter([tWater, tWater], [1]);
-			var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -4, 2);
-			createArea(placer, [painter, elevationPainter], avoidClasses(clPlayer, 3));
-		}
-	}
+	let point = getTIPIADBON(
+		[fractionToTiles(cLocation), fractionToTiles(0.5 + cDistance)],
+		[fractionToTiles(cLocation), fractionToTiles(0.5 - cDistance)],
+		[-6, -1.5],
+		0.5,
+		5,
+		0.01);
+
+	if (point === undefined)
+		continue;
+
+	let fx = fractionToTiles(0.5 + 0.49 * Math.cos(tang));
+	let fz = fractionToTiles(0.5 + 0.49 * Math.sin(tang));
+
+	log("Creating tributary river...");
+	let success = createArea(
+		new PathPlacer(
+			Math.floor(point[0]),
+			Math.floor(point[1]),
+			Math.floor(fx),
+			Math.floor(fz),
+			riverWidth,
+			0.4,
+			3 * scaleByMapSize(1, 4),
+			0.1,
+			0.05),
+		[
+			new SmoothElevationPainter(ELEVATION_SET, waterHeight, 4),
+			paintClass(clWater)
+		],
+		avoidClasses(clPlayer, 3, clWater, 3, clShallow, 2));
+
+	if (success === undefined)
+		continue;
+
+	log("Creating small puddles at the map border to ensure players being separated...");
+	createArea(
+		new ClumpPlacer(Math.floor(Math.PI * Math.pow(riverWidth, 2) / 4), 0.95, 0.6, 10, fx, fz),
+		new SmoothElevationPainter(ELEVATION_SET, waterHeight, 2),
+		avoidClasses(clPlayer, 3));
 }
 
-passageMaker(floor(fractionToTiles(0.2)), floor(fractionToTiles(0.25)), floor(fractionToTiles(0.8)), floor(fractionToTiles(0.25)), scaleByMapSize(4,8), -2, -2, 2, clShallow, undefined, -4);
-passageMaker(floor(fractionToTiles(0.2)), floor(fractionToTiles(0.75)), floor(fractionToTiles(0.8)), floor(fractionToTiles(0.75)), scaleByMapSize(4,8), -2, -2, 2, clShallow, undefined, -4);
+log("Creating shallows to make tributaries passable...");
+for (let coord of [0.25, 0.75])
+	passageMaker(
+		Math.floor(fractionToTiles(0.2)),
+		Math.floor(fractionToTiles(coord)),
+		Math.floor(fractionToTiles(0.8)),
+		Math.floor(fractionToTiles(coord)),
+		scaleByMapSize(4, 8),
+		-2,
+		-2,
+		2,
+		clShallow,
+		undefined,
+		waterHeight);
 
 paintTerrainBasedOnHeight(-5, 1, 1, tWater);
 paintTerrainBasedOnHeight(1, 2, 1, pForestR);
@@ -217,15 +250,12 @@ paintTileClassBasedOnHeight(-6, 0.5, 1, clWater);
 RMS.SetProgress(50);
 
 log("Creating bumps...");
-placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1);
-painter = new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2);
 createAreas(
-	placer,
-	painter,
+	new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1),
+	new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2),
 	avoidClasses(clWater, 2, clPlayer, 15),
 	scaleByMapSize(100, 200)
 );
-
 RMS.SetProgress(55);
 
 // calculate desired number of trees for map (based on size)
@@ -241,64 +271,48 @@ log("Creating forests...");
 var types = [
 	[[tGrassDForest, tGrass, pForestB], [tGrassDForest, pForestB]],
 	[[tGrassPForest, tGrass, pForestO], [tGrassPForest, pForestO]]
-];	// some variation
-var size = numForest / (scaleByMapSize(3,6) * numPlayers);
-var num = floor(size / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), numForest / num, 0.5);
-	painter = new LayeredPainter(
-		types[i],		// terrains
-		[2]											// widths
-		);
+];
+var size = numForest / (scaleByMapSize(3, 6) * numPlayers);
+var num = Math.floor(size / types.length);
+for (let type of types)
 	createAreas(
-		placer,
-		[painter, paintClass(clForest)],
-		avoidClasses(clPlayer, 15, clWater, 3, clForest, 16, clHill, 1),
-		num
-	);
-}
-
+		new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), numForest / num, 0.5),
+		[
+			new LayeredPainter(type, [2]),
+			paintClass(clForest)
+		],
+		avoidClasses(
+			clPlayer, 15,
+			clWater, 3,
+			clForest, 16,
+			clHill, 1),
+		num);
 RMS.SetProgress(70);
 
 log("Creating dirt patches...");
-var sizes = [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)];
-for (var i = 0; i < sizes.length; i++)
-{
-	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
-	painter = new LayeredPainter(
-		[[tGrass,tGrassA], tGrassB, [tGrassB,tGrassC]], 		// terrains
-		[1,1]															// widths
-	);
+for (let size of [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)])
 	createAreas(
-		placer,
-		[painter, paintClass(clDirt)],
+		new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
+		[
+			new LayeredPainter([[tGrass,tGrassA], tGrassB, [tGrassB,tGrassC]], [1, 1]),
+			paintClass(clDirt)
+		],
 		avoidClasses(clWater, 1, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 6),
 		scaleByMapSize(15, 45)
 	);
-}
 
 log("Creating grass patches...");
-var sizes = [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)];
-for (var i = 0; i < sizes.length; i++)
-{
-	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
-	painter = new LayeredPainter(
-		[tGrassPatchBlend, tGrassPatch], 		// terrains
-		[1]															// widths
-	);
+for (let size of [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)])
 	createAreas(
-		placer,
-		painter,
+		new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
+		new LayeredPainter([tGrassPatchBlend, tGrassPatch], [1]),
 		avoidClasses(clWater, 1, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 6),
 		scaleByMapSize(15, 45)
 	);
-}
-
 RMS.SetProgress(80);
 
 log("Creating stone mines...");
-group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
+var group = new SimpleGroup([new SimpleObject(oStoneSmall, 0, 2, 0, 4), new SimpleObject(oStoneLarge, 1, 1, 0, 4)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clWater, 0, clForest, 1, clPlayer, 15, clRock, 10, clHill, 1)],
 	scaleByMapSize(4,16), 100
@@ -373,19 +387,14 @@ createObjectGroupsDeprecated(group, 0,
 );
 
 log("Creating straggler trees...");
-var types = [oOak, oBeech];	// some variation
+var types = [oOak, oBeech];
 var num = floor(numStragglers / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	group = new SimpleGroup(
-		[new SimpleObject(types[i], 1,1, 0,3)],
-		true, clForest
-	);
-	createObjectGroupsDeprecated(group, 0,
+for (let type of types)
+	createObjectGroupsDeprecated(
+		new SimpleGroup([new SimpleObject(type, 1, 1, 0, 3)], true, clForest),
+		0,
 		avoidClasses(clWater, 1, clForest, 7, clHill, 1, clPlayer, 5, clMetal, 6, clRock, 6),
-		num
-	);
-}
+		num);
 
 log("Creating small grass tufts...");
 group = new SimpleGroup(
diff --git a/binaries/data/mods/public/maps/random/mainland.js b/binaries/data/mods/public/maps/random/mainland.js
index 390946595d..e2d8751b07 100644
--- a/binaries/data/mods/public/maps/random/mainland.js
+++ b/binaries/data/mods/public/maps/random/mainland.js
@@ -233,7 +233,6 @@ createFood
 
 RMS.SetProgress(85);
 
-var types = [oTree1, oTree2, oTree4, oTree3];	// some variation
-createStragglerTrees(types);
+createStragglerTrees([oTree1, oTree2, oTree4, oTree3]);
 
 ExportMap();
diff --git a/binaries/data/mods/public/maps/random/migration.js b/binaries/data/mods/public/maps/random/migration.js
index 5f464b55ca..43de458507 100644
--- a/binaries/data/mods/public/maps/random/migration.js
+++ b/binaries/data/mods/public/maps/random/migration.js
@@ -57,6 +57,8 @@ var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clLand = createTileClass();
 
+var landHeight = 3;
+
 var playerIDs = sortAllPlayers();
 
 // place players
@@ -170,71 +172,69 @@ for (var i = 0; i < numPlayers; i++)
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 
-	//create docks
-	var dockLocation = getTIPIADBON([ix, iz], [mapSize / 2, mapSize / 2], [-3 , 2.6], 0.5, 3);
-	if (dockLocation !== undefined)
-		placeObject(dockLocation[0], dockLocation[1], "structures/" + getCivCode(id-1) + "_dock", id, playerAngle[i] + PI);
+	let dockLocation = getTIPIADBON([ix, iz], [mapSize / 2, mapSize / 2], [-3 , 2.6], 0.5, 3);
+	if (dockLocation === undefined)
+	{
+		warn("Could not place dock for player " + playerIDs[i])
+		continue;
+	}
+
+	placeObject(
+		dockLocation[0],
+		dockLocation[1],
+		"structures/" + getCivCode(playerIDs[i] - 1) + "_dock",
+		playerIDs[i] - 1,
+		playerAngle[i] + Math.PI);
 }
 RMS.SetProgress(15);
 
-//Create the continent body
-var fx = fractionToTiles(0.12);
-var fz = fractionToTiles(0.5);
-var ix = round(fx);
-var iz = round(fz);
-
-var placer = new ClumpPlacer(mapArea * 0.50, 0.80, 0.08, 10, ix, iz);
-var terrainPainter = new LayeredPainter(
-	[tWater, tShore, tMainTerrain],		// terrains
-	[4, 2]		// widths
-);
-var elevationPainter = new SmoothElevationPainter(
-	ELEVATION_SET,			// type
-	3,				// elevation
-	4				// blend radius
-);
-createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], avoidClasses(clPlayer, 8));
+log("Create the continent body...");
+createArea(
+	new ClumpPlacer(mapArea * 0.50, 0.8, 0.08, 10,  Math.round(fractionToTiles(0.12)), Math.round(fractionToTiles(0.5))),
+	[
+		new LayeredPainter([tWater, tShore, tMainTerrain], [4, 2]),
+		new SmoothElevationPainter(ELEVATION_SET, landHeight, 4),
+		paintClass(clLand)
+	],
+	avoidClasses(clPlayer, 8));
 RMS.SetProgress(20);
 
 log("Creating shore jaggedness...");
-placer = new ClumpPlacer(scaleByMapSize(15, 80), 0.2, 0.1, 1);
-terrainPainter = new LayeredPainter(
-	[tMainTerrain, tMainTerrain],		// terrains
-	[2]								// widths
-);
-elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 4);
 createAreas(
-	placer,
-	[terrainPainter, elevationPainter, paintClass(clLand)],
-	[borderClasses(clLand, 6, 3), avoidClasses(clPlayer, 8)],
-	scaleByMapSize(20, 150) * 2, 150
-);
+	new ClumpPlacer(scaleByMapSize(15, 80), 0.2, 0.1, 1),
+	[
+		new LayeredPainter([tMainTerrain, tMainTerrain], [2]),
+		new SmoothElevationPainter(ELEVATION_SET, landHeight, 4),
+		paintClass(clLand)
+	],
+	[
+		borderClasses(clLand, 6, 3),
+		avoidClasses(clPlayer, 8)
+	],
+	scaleByMapSize(2, 15) * 20,
+	150);
 
 paintTerrainBasedOnHeight(1, 3, 0, tShore);
 paintTerrainBasedOnHeight(-8, 1, 2, tWater);
 RMS.SetProgress(25);
 
 log("Creating bumps...");
-placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1);
-painter = new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2);
 createAreas(
-	placer,
-	painter,
+	new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1),
+	new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2),
 	[avoidClasses(clPlayer, 10), stayClasses(clLand, 3)],
 	scaleByMapSize(100, 200)
 );
 RMS.SetProgress(30);
 
 log("Creating hills...");
-placer = new ClumpPlacer(scaleByMapSize(20, 150), 0.2, 0.1, 1);
-terrainPainter = new LayeredPainter(
-	[tCliff, tHill],		// terrains
-	[2]								// widths
-);
-elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 18, 2);
 createAreas(
-	placer,
-	[terrainPainter, elevationPainter, paintClass(clHill)],
+	new ClumpPlacer(scaleByMapSize(20, 150), 0.2, 0.1, 1),
+	[
+		new LayeredPainter([tCliff, tHill], [2]),
+		new SmoothElevationPainter(ELEVATION_SET, 18, 2),
+		paintClass(clHill)
+	],
 	[avoidClasses(clPlayer, 10, clHill, 15), stayClasses(clLand, 7)],
 	scaleByMapSize(1, 4) * numPlayers
 );
@@ -268,63 +268,56 @@ log("Creating forests...");
 var types = [
 	[[tForestFloor2, tMainTerrain, pForest1], [tForestFloor2, pForest1]],
 	[[tForestFloor1, tMainTerrain, pForest2], [tForestFloor1, pForest2]]
-];	// some variation
+];
 
 var size = numForest / (scaleByMapSize(2,8) * numPlayers) *
 	(currentBiome() == "savanna" ? 2 : 1);
 
 var num = floor(size / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	placer = new ClumpPlacer(numForest / num, 0.1, 0.1, 1);
-	painter = new LayeredPainter(
-		types[i],		// terrains
-		[2]											// widths
-		);
+for (let type of types)
 	createAreas(
-		placer,
-		[painter, paintClass(clForest)],
+		new ClumpPlacer(numForest / num, 0.1, 0.1, 1),
+		[
+			new LayeredPainter(type, [2]),
+			paintClass(clForest)
+		],
 		[avoidClasses(clPlayer, 6, clForest, 10, clHill, 0), stayClasses(clLand, 7)],
-		num
-	);
-}
+		num);
 RMS.SetProgress(38);
 
 log("Creating dirt patches...");
-var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
-for (var i = 0; i < sizes.length; i++)
-{
-	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
-	painter = new LayeredPainter(
-		[[tMainTerrain,tTier1Terrain],[tTier1Terrain,tTier2Terrain], [tTier2Terrain,tTier3Terrain]], 		// terrains
-		[1,1]															// widths
-	);
+for (let size of [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)])
 	createAreas(
-		placer,
-		[painter, paintClass(clDirt)],
-		[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 0), stayClasses(clLand, 7)],
-		scaleByMapSize(15, 45)
-	);
-}
+		new ClumpPlacer(size, 0.3, 0.06, 0.5),
+		[
+			new LayeredPainter(
+				[[tMainTerrain, tTier1Terrain], [tTier1Terrain, tTier2Terrain], [tTier2Terrain, tTier3Terrain]],
+				[1, 1]),
+			paintClass(clDirt)
+		],
+		[
+			avoidClasses(
+				clForest, 0,
+				clHill, 0,
+				clDirt, 5,
+				clPlayer, 0),
+			stayClasses(clLand, 7)
+		],
+		scaleByMapSize(15, 45));
+
 RMS.SetProgress(42);
 
 log("Creating grass patches...");
-var sizes = [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)];
-for (var i = 0; i < sizes.length; i++)
-{
-	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
-	painter = new TerrainPainter(tTier4Terrain);
+for (let size of [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)])
 	createAreas(
-		placer,
-		painter,
+		new ClumpPlacer(size, 0.3, 0.06, 0.5),
+		new TerrainPainter(tTier4Terrain),
 		[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 0), stayClasses(clLand, 7)],
-		scaleByMapSize(15, 45)
-	);
-}
+		scaleByMapSize(15, 45));
 RMS.SetProgress(46);
 
 log("Creating stone mines...");
-group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
+var group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 10, clRock, 10, clHill, 1), stayClasses(clLand, 7)],
 	scaleByMapSize(4,16), 100
@@ -414,19 +407,14 @@ createObjectGroupsDeprecated(
 RMS.SetProgress(82);
 
 log("Creating straggler trees...");
-var types = [oTree1, oTree2, oTree4, oTree3];	// some variation
+var types = [oTree1, oTree2, oTree4, oTree3];
 var num = floor(numStragglers / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	group = new SimpleGroup(
-		[new SimpleObject(types[i], 1,1, 0,3)],
-		true, clForest
-	);
-	createObjectGroupsDeprecated(group, 0,
+for (let type of types)
+	createObjectGroupsDeprecated(
+		new SimpleGroup([new SimpleObject(type, 1, 1, 0, 3)], true, clForest),
+		0,
 		[avoidClasses(clForest, 1, clHill, 1, clPlayer, 9, clMetal, 6, clRock, 6), stayClasses(clLand, 9)],
-		num
-	);
-}
+		num);
 RMS.SetProgress(86);
 
 var planetm = currentBiome() == "tropic" ? 8 : 1;
diff --git a/binaries/data/mods/public/maps/random/neareastern_badlands.js b/binaries/data/mods/public/maps/random/neareastern_badlands.js
index b20cd0aae9..81c07d512b 100644
--- a/binaries/data/mods/public/maps/random/neareastern_badlands.js
+++ b/binaries/data/mods/public/maps/random/neareastern_badlands.js
@@ -163,10 +163,15 @@ RMS.SetProgress(25);
 
 log("Creating oasis...");
 var oRadius = scaleByMapSize(14, 40);
-placer = new ClumpPlacer(PI*oRadius*oRadius, 0.6, 0.15, 0, mapSize/2, mapSize/2);
-painter = new LayeredPainter([[tSand, pForest], [tGrassSand25, pForestOasis], tGrassSand25, tShore, tWaterDeep], [2, 3, 1, 1]);
-elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, -11, 8);
-createArea(placer, [painter, elevationPainter, paintClass(clForest)], null);
+createArea(
+	new ClumpPlacer(Math.PI * Math.pow(oRadius, 2), 0.6, 0.15, 0, mapSize/2, mapSize/2),
+	[
+		new LayeredPainter([[tSand, pForest], [tGrassSand25, pForestOasis], tGrassSand25, tShore, tWaterDeep], [2, 3, 1, 1]),
+		new SmoothElevationPainter(ELEVATION_MODIFY, -11, 8),
+		paintClass(clForest)
+	],
+	null);
+
 RMS.SetProgress(30);
 
 log("Creating oasis wildlife...");
@@ -184,13 +189,17 @@ for (var i = 0; i < num; ++i)
 		++r;
 	} while (!constraint.allows(gx,gz) && r < halfSize);
 
-	group = new RandomGroup(
-		[	new SimpleObject(oGiraffe, 2,4, 0,3),		// select from these groups randomly
-			new SimpleObject(oWildebeest, 3,5, 0,3),
-			new SimpleObject(oGazelle, 5,7, 0,3)
-		], true, clFood, gx, gz
-	);
-	createObjectGroup(group, 0);
+	createObjectGroup(
+		new RandomGroup(
+			[	new SimpleObject(oGiraffe, 2,4, 0,3),
+				new SimpleObject(oWildebeest, 3,5, 0,3),
+				new SimpleObject(oGazelle, 5,7, 0,3)
+			],
+			true,
+			clFood,
+			gx,
+			gz),
+		0);
 }
 
 constraint = new AndConstraint([borderClasses(clForest, 15, 0), avoidClasses(clFood, 5)]);
@@ -215,79 +224,76 @@ for (var i = 0; i < num; ++i)
 RMS.SetProgress(35);
 
 log("Creating level 1 hills...");
-placer = new ClumpPlacer(scaleByMapSize(50,300), 0.25, 0.1, 0.5);
-var terrainPainter = new LayeredPainter(
-	[tCliff, tSand],		// terrains
-	[1]				// widths
-);
-var elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, 16, 1);
-var hillAreas = createAreas(placer, [terrainPainter, elevationPainter, paintClass(clHill1)],
+var hillAreas = createAreas(
+	new ClumpPlacer(scaleByMapSize(50,300), 0.25, 0.1, 0.5),
+	[
+		new LayeredPainter([tCliff, tSand], [1]),
+		new SmoothElevationPainter(ELEVATION_MODIFY, 16, 1),
+		paintClass(clHill1)
+	],
 	avoidClasses(clForest, 3, clPlayer, 0, clHill1, 10),
 	scaleByMapSize(10,20), 100
 );
 RMS.SetProgress(40);
 
 log("Creating small level 1 hills...");
-placer = new ClumpPlacer(scaleByMapSize(25,150), 0.25, 0.1, 0.5);
-terrainPainter = new LayeredPainter(
-	[tCliff, tSand],		// terrains
-	[1]				// widths
-);
-elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, 16, 1);
-var tempAreas = createAreas(placer, [terrainPainter, elevationPainter, paintClass(clHill1)],
-	avoidClasses(clForest, 3, clPlayer, 0, clHill1, 3),
-	scaleByMapSize(15,25), 100
-);
-for (var i = 0; i < tempAreas.length; ++i)
-	hillAreas.push(tempAreas[i]);
+hillAreas = hillAreas.concat(
+	createAreas(
+		new ClumpPlacer(scaleByMapSize(25,150), 0.25, 0.1, 0.5),
+		[
+			new LayeredPainter([tCliff, tSand], [1]),
+			new SmoothElevationPainter(ELEVATION_MODIFY, 16, 1),
+			paintClass(clHill1)
+		],
+		avoidClasses(clForest, 3, clPlayer, 0, clHill1, 3),
+		scaleByMapSize(15,25),
+		100));
+
 RMS.SetProgress(45);
 
 log("Creating decorative rocks...");
-group = new SimpleGroup(
-	[new RandomObject([aDecorativeRock, aBush2, aBush3], 3,8, 0,2)],
-	true
-);
-createObjectGroupsByAreasDeprecated(group, 0,
+createObjectGroupsByAreasDeprecated(
+	new SimpleGroup(
+		[new RandomObject([aDecorativeRock, aBush2, aBush3], 3, 8, 0, 2)],
+		true),
+	0,
 	borderClasses(clHill1, 0, 3),
 	scaleByMapSize(40,200), 50,
-	hillAreas
-);
+	hillAreas);
 
 RMS.SetProgress(50);
 
 log("Creating level 2 hills...");
-placer = new ClumpPlacer(scaleByMapSize(25,150), 0.25, 0.1, 0);
-terrainPainter = new LayeredPainter(
-	[tCliff, tSand],		// terrains
-	[1]				// widths
-);
-elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, 16, 1);
-createAreasInAreas(placer, [terrainPainter, elevationPainter],
+createAreasInAreas(
+	new ClumpPlacer(scaleByMapSize(25, 150), 0.25, 0.1, 0),
+	[
+		new LayeredPainter([tCliff, tSand], [1]),
+		new SmoothElevationPainter(ELEVATION_MODIFY, 16, 1)
+	],
 	[stayClasses(clHill1, 0)],
-	scaleByMapSize(15,25), 50,
-	hillAreas
-);
+	scaleByMapSize(15, 25),
+	50,
+	hillAreas);
+
 RMS.SetProgress(55);
 
 log("Creating level 3 hills...");
-placer = new ClumpPlacer(scaleByMapSize(12, 75), 0.25, 0.1, 0);
-terrainPainter = new LayeredPainter(
-	[tCliff, tSand],		// terrains
-	[1]				// widths
-);
-elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, 16, 1);
-createAreas(placer, [terrainPainter, elevationPainter],
+createAreas(
+	new ClumpPlacer(scaleByMapSize(12, 75), 0.25, 0.1, 0),
+	[
+		new LayeredPainter([tCliff, tSand], [1]),
+		new SmoothElevationPainter(ELEVATION_MODIFY, 16, 1)
+	],
 	[stayClasses(clHill1, 0)],
-	scaleByMapSize(15,25), 50
+	scaleByMapSize(15,25),
+	50
 );
 RMS.SetProgress(60);
 
 log("Creating bumps...");
-placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 0);
-elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2);
 createAreas(
-	placer,
-	elevationPainter,
+	new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 0),
+	new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2),
 	avoidClasses(clForest, 0, clPlayer, 0, clHill1, 2),
 	scaleByMapSize(100, 200)
 );
@@ -315,7 +321,7 @@ createAreas(placer, [painter, paintClass(clForest)],
 RMS.SetProgress(70);
 
 log("Creating stone mines...");
-group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4), new RandomObject(aBushes, 2,4, 0,2)], true, clRock);
+var group = new SimpleGroup([new SimpleObject(oStoneSmall, 0, 2, 0, 4), new SimpleObject(oStoneLarge, 1, 1, 0, 4), new RandomObject(aBushes, 2, 4, 0, 2)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 10, clRock, 10, clHill1, 1)],
 	scaleByMapSize(4,16), 100
@@ -359,16 +365,14 @@ createObjectGroupsDeprecated(group, 0,
 RMS.SetProgress(85);
 
 log("Creating straggler trees...");
-var types = [oDatePalm, oSDatePalm];	// some variation
+var types = [oDatePalm, oSDatePalm];
 var num = floor(numStragglers / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	group = new SimpleGroup([new SimpleObject(types[i], 1,1, 0,0)], true);
-	createObjectGroupsDeprecated(group, 0,
+for (let type of types)
+	createObjectGroupsDeprecated(
+		new SimpleGroup([new SimpleObject(type, 1, 1, 0, 0)], true),
+		0,
 		avoidClasses(clForest, 0, clHill1, 1, clPlayer, 4, clMetal, 6, clRock, 6),
-		num
-	);
-}
+		num);
 RMS.SetProgress(90);
 
 log("Creating bushes...");
diff --git a/binaries/data/mods/public/maps/random/northern_lights.js b/binaries/data/mods/public/maps/random/northern_lights.js
index 2bb817962f..084c85a7cd 100644
--- a/binaries/data/mods/public/maps/random/northern_lights.js
+++ b/binaries/data/mods/public/maps/random/northern_lights.js
@@ -134,37 +134,28 @@ paintRiver({
 
 log("Creating shores...");
 for (var i = 0; i < scaleByMapSize(20,120); i++)
-{
-	placer = new ChainPlacer(
-		1,
-		Math.floor(scaleByMapSize(4, 6)),
-		Math.floor(scaleByMapSize(16, 30)),
-		1,
-		randIntExclusive(0.1 * mapSize, 0.9 * mapSize),
-		randIntExclusive(0.67 * mapSize, 0.74 * mapSize));
-
-	var terrainPainter = new LayeredPainter(
-		[tSnowA, tSnowA],		// terrains
-		[2]								// widths
-	);
-	var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 3);
 	createArea(
-		placer,
-		[terrainPainter, elevationPainter, unPaintClass(clWater)],
-		null
-	);
-}
+		new ChainPlacer(
+			1,
+			Math.floor(scaleByMapSize(4, 6)),
+			Math.floor(scaleByMapSize(16, 30)),
+			1,
+			randIntExclusive(0.1 * mapSize, 0.9 * mapSize),
+			randIntExclusive(0.67 * mapSize, 0.74 * mapSize)),
+		[
+			new LayeredPainter([tSnowA, tSnowA], [2]),
+			new SmoothElevationPainter(ELEVATION_SET, 3, 3), unPaintClass(clWater)
+		],
+		null);
 
 log("Creating islands...");
-placer = new ChainPlacer(1, floor(scaleByMapSize(4, 6)), floor(scaleByMapSize(16, 40)), 0.1);
-var terrainPainter = new LayeredPainter(
-	[tSnowA, tSnowA],		// terrains
-	[3]								// widths
-);
-var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 3);
 createAreas(
-	placer,
-	[terrainPainter, elevationPainter, unPaintClass(clWater)],
+	new ChainPlacer(1, Math.floor(scaleByMapSize(4, 6)), Math.floor(scaleByMapSize(16, 40)), 0.1),
+	[
+		new LayeredPainter([tSnowA, tSnowA], [3]),
+		new SmoothElevationPainter(ELEVATION_SET, 3, 3),
+		unPaintClass(clWater)
+	],
 	stayClasses(clWater, 7),
 	scaleByMapSize(10, 80)
 );
@@ -172,19 +163,15 @@ createAreas(
 paintTerrainBasedOnHeight(-6, 1, 1, tWater);
 
 log("Creating lakes...");
-var numLakes = round(scaleByMapSize(1,4) * numPlayers);
-var placer = new ChainPlacer(1, floor(scaleByMapSize(5, 7)), floor(scaleByMapSize(20, 50)), 0.1);
-var terrainPainter = new LayeredPainter(
-	[tShoreBlend, tShore, tWater],		// terrains
-	[1,1]							// widths
-);
-var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -4, 3);
-var waterAreas = createAreas(
-	placer,
-	[terrainPainter, elevationPainter, paintClass(clWater)],
+createAreas(
+	new ChainPlacer(1, Math.floor(scaleByMapSize(5, 7)), Math.floor(scaleByMapSize(20, 50)), 0.1),
+	[
+		new LayeredPainter([tShoreBlend, tShore, tWater], [1, 1]),
+		new SmoothElevationPainter(ELEVATION_SET, -4, 3),
+		paintClass(clWater)
+	],
 	avoidClasses(clPlayer, 20, clWater, 20),
-	numLakes
-);
+	Math.round(scaleByMapSize(1, 4) * numPlayers));
 
 paintTerrainBasedOnHeight(1, 2.8, 1, tShoreBlend);
 paintTileClassBasedOnHeight(-6, 0.5, 1, clWater);
@@ -192,21 +179,18 @@ paintTileClassBasedOnHeight(-6, 0.5, 1, clWater);
 RMS.SetProgress(45);
 
 log("Creating hills...");
-placer = new ChainPlacer(1, floor(scaleByMapSize(4, 6)), floor(scaleByMapSize(16, 40)), 0.1);
-var terrainPainter = new LayeredPainter(
-	[tCliff, tSnowA],		// terrains
-	[3]								// widths
-);
-var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 25, 3);
 createAreas(
-	placer,
-	[terrainPainter, elevationPainter, paintClass(clHill)],
+	new ChainPlacer(1, Math.floor(scaleByMapSize(4, 6)), Math.floor(scaleByMapSize(16, 40)), 0.1),
+	[
+		new LayeredPainter([tCliff, tSnowA], [3]),
+		new SmoothElevationPainter(ELEVATION_SET, 25, 3),
+		paintClass(clHill)
+	],
 	avoidClasses(clPlayer, 20, clHill, 15, clWater, 2, clBaseResource, 2),
 	scaleByMapSize(1, 4) * numPlayers
 );
 
 // calculate desired number of trees for map (based on size)
-
 var MIN_TREES = 100;
 var MAX_TREES = 625;
 var P_FOREST = 0.7;
@@ -219,69 +203,63 @@ log("Creating forests...");
 var types = [
 	[[tSnowA, tSnowA, tSnowA, tSnowA, pForestD], [tSnowA, tSnowA, tSnowA, pForestD]],
 	[[tSnowA, tSnowA, tSnowA, tSnowA, pForestS], [tSnowA, tSnowA, tSnowA, pForestS]]
-];	// some variation
+];
 
 var size = numForest / (scaleByMapSize(3,6) * numPlayers);
 
 var num = floor(size / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), numForest / (num * floor(scaleByMapSize(2,4))), 1);
-	painter = new LayeredPainter(
-		types[i],		// terrains
-		[2]											// widths
-		);
+for (let type of types)
 	createAreas(
-		placer,
-		[painter, paintClass(clForest)],
+		new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), numForest / (num * Math.floor(scaleByMapSize(2, 4))), 1),
+		[
+			new LayeredPainter(type, [2]),
+			paintClass(clForest)
+		],
 		avoidClasses(clPlayer, 20, clForest, 20, clHill, 0, clWater, 8),
-		num
-	);
-}
+		num);
 
 log("Creating iceberg...");
-group = new SimpleGroup([new SimpleObject(aIceberg, 0,2, 0,4)], true, clRock);
-createObjectGroupsDeprecated(group, 0,
+createObjectGroupsDeprecated(
+	new SimpleGroup([new SimpleObject(aIceberg, 0, 2, 0, 4)], true, clRock),
+	0,
 	[avoidClasses(clRock, 6), stayClasses(clWater, 4)],
-	scaleByMapSize(4,16), 100
-);
-
+	scaleByMapSize(4, 16),
+	100);
 RMS.SetProgress(70);
 
 log("Creating dirt patches...");
-var sizes = [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)];
-for (var i = 0; i < sizes.length; i++)
-{
-	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
-	painter = new LayeredPainter(
-		[tSnowD,tSnowB,tSnowC], 		// terrains
-		[2,1]															// widths
-	);
+for (let size of [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)])
 	createAreas(
-		placer,
-		[painter, paintClass(clDirt)],
-		avoidClasses(clWater, 8, clForest, 0, clHill, 0, clPlayer, 20, clDirt, 16),
-		scaleByMapSize(20, 80)
-	);
-}
-var sizes = [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)];
-for (var i = 0; i < sizes.length; i++)
-{
-	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
-	painter = new LayeredPainter(
-		[tSnowE,tSnowE], 		// terrains
-		[1]															// widths
-	);
+		new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
+		[
+			new LayeredPainter([tSnowD, tSnowB, tSnowC], [2, 1]),
+			paintClass(clDirt)
+		],
+		avoidClasses(
+			clWater, 8,
+			clForest, 0,
+			clHill, 0,
+			clPlayer, 20,
+			clDirt, 16),
+		scaleByMapSize(20, 80));
+
+for (let size of [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)])
 	createAreas(
-		placer,
-		[painter, paintClass(clDirt)],
-		avoidClasses(clWater, 8, clForest, 0, clHill, 0, clPlayer, 20, clDirt, 16),
-		scaleByMapSize(20, 80)
-	);
-}
+		new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
+		[
+			new LayeredPainter([tSnowE, tSnowE], [1]),
+			paintClass(clDirt)
+		],
+		avoidClasses(
+			clWater, 8,
+			clForest, 0,
+			clHill, 0,
+			clPlayer, 20,
+			clDirt, 16),
+		scaleByMapSize(20, 80));
 
 log("Creating stone mines...");
-group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
+var group = new SimpleGroup([new SimpleObject(oStoneSmall, 0, 2, 0, 4), new SimpleObject(oStoneLarge, 1, 1, 0, 4)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clRock, 10, clHill, 1),
 	scaleByMapSize(8,32), 100
@@ -303,19 +281,14 @@ createObjectGroupsDeprecated(group, 0,
 RMS.SetProgress(95);
 
 log("Creating straggler trees...");
-var types = [oPine];	// some variation
+var types = [oPine];
 var num = floor(numStragglers / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	group = new SimpleGroup(
-		[new SimpleObject(types[i], 1,1, 0,3)],
-		true, clForest
-	);
-	createObjectGroupsDeprecated(group, 0,
+for (let type of types)
+	createObjectGroupsDeprecated(
+		new SimpleGroup([new SimpleObject(type, 1, 1, 0, 3)], true, clForest),
+		0,
 		avoidClasses(clWater, 5, clForest, 1, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6),
-		num
-	);
-}
+		num);
 
 log("Creating deer...");
 group = new SimpleGroup(
diff --git a/binaries/data/mods/public/maps/random/oasis.js b/binaries/data/mods/public/maps/random/oasis.js
index 9e92204594..156e58c3bb 100644
--- a/binaries/data/mods/public/maps/random/oasis.js
+++ b/binaries/data/mods/public/maps/random/oasis.js
@@ -129,87 +129,118 @@ for (var i = 0; i < numPlayers; i++)
 							true, clBaseResource, mX, mZ
 							);
 	createObjectGroup(group, 0);
+
 	// Create starting batches of wood
-	var types = [tForestFloor, pForestMain];	// some variation
-	var forestX = 0;
-	var forestY = 0;
-	var forestAngle = 0;
+	let forestX = 0;
+	let forestY = 0;
+	let forestAngle = 0
+	let forestDist = radius * 1.2;
+
 	do {
-		forestAngle = mAngle + randFloat(PI/2, (2*PI)/3);
-		var forestDist = radius * 1.2;
-		forestX = round(fx + forestDist * cos(forestAngle));
-		forestY = round(fz + forestDist * sin(forestAngle));
-		placer = new ClumpPlacer(70, 1.0, 0.5, 10,forestX,forestY);
-		painter = new LayeredPainter(types, [0] );
-	} while (createArea( placer, [painter, paintClass(clBaseResource)], avoidClasses(clBaseResource, 0) ) === undefined);
-	// creating the water patch explaining the forest
+		forestAngle = Math.PI / 3 * randFloat(1, 2);
+		forestX = Math.round(fx + forestDist * Math.cos(forestAngle));
+		forestY = Math.round(fz + forestDist * Math.sin(forestAngle));
+	} while (
+		!createArea(
+			new ClumpPlacer(70, 1, 0.5, 10, forestX, forestY),
+			[
+				new LayeredPainter([tForestFloor, pForestMain], [0]),
+				paintClass(clBaseResource)
+			],
+			avoidClasses(clBaseResource, 0)));
+
+	// Creating the water patch explaining the forest
 	do {
 		var watAngle = forestAngle + randFloat((PI/3), (5*PI/3));
 		var watX = round(forestX + 6 * cos(watAngle));
 		var watY = round(forestY + 6 * sin(watAngle));
-		placer = new ClumpPlacer(60, 0.9, 0.4, 5,watX,watY);
-		terrainPainter = new LayeredPainter( [tShore,tShoreBlend], [1] );
-		painter = new SmoothElevationPainter(ELEVATION_MODIFY, -5, 3);
-		group = new SimpleGroup( [new SimpleObject(aFlower1, 1,5, 0,3)], true, undefined, round(forestX + 3 * cos(watAngle)),round(forestY + 3 * sin(watAngle)) );
-		createObjectGroup(group, 0);
-		group = new SimpleGroup( [new SimpleObject(aReedsA, 1,3, 0,0)], true, undefined, round(forestX + 5 * cos(watAngle)),round(forestY + 5 * sin(watAngle)) );
-		createObjectGroup(group, 0);
-	} while (createArea( placer, [terrainPainter, painter],  avoidClasses(clBaseResource,0) ) === undefined);
 
-	// TODO: add a few random trees here and there
+		createObjectGroup(
+			new SimpleGroup(
+				[new SimpleObject(aFlower1, 1, 5, 0, 3)],
+				true,
+				undefined,
+				Math.round(forestX + 3 * Math.cos(watAngle)),
+				Math.round(forestY + 3 * Math.sin(watAngle))),
+			0);
+
+		createObjectGroup(
+			new SimpleGroup(
+				[new SimpleObject(aReedsA, 1, 3, 0, 0)],
+				true,
+				undefined,
+				Math.round(forestX + 5 * Math.cos(watAngle)),
+				Math.round(forestY + 5 * Math.sin(watAngle))),
+			0);
+
+	} while (
+		!createArea(
+			new ClumpPlacer(60, 0.9, 0.4, 5, watX, watY),
+			[
+				new LayeredPainter([tShore, tShoreBlend], [1]),
+				new SmoothElevationPainter(ELEVATION_MODIFY, -5, 3)
+			],
+			avoidClasses(clBaseResource, 0)));
 }
 RMS.SetProgress(20);
 
 log("Creating bumps...");
-placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1);
-painter = new SmoothElevationPainter(ELEVATION_MODIFY, 4, 3);
-createAreas( placer, painter,
-			avoidClasses(clPlayer, 10, clBaseResource, 6),
-			scaleByMapSize(30, 70)
-			);
+createAreas(
+	new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1),
+	new SmoothElevationPainter(ELEVATION_MODIFY, 4, 3),
+	avoidClasses(clPlayer, 10, clBaseResource, 6),
+	scaleByMapSize(30, 70));
+
 log("Creating dirt Patches...");
-placer = new ClumpPlacer(80, 0.3, 0.06, 1);
-var terrainPainter = new TerrainPainter(tDirt);
-createAreas(placer, terrainPainter, avoidClasses(clPlayer, 10, clBaseResource, 6), scaleByMapSize(15, 50) );
+createAreas(
+	new ClumpPlacer(80, 0.3, 0.06, 1),
+	new TerrainPainter(tDirt),
+	avoidClasses(clPlayer, 10, clBaseResource, 6),
+	scaleByMapSize(15, 50));
 
 log("Creating Dunes...");
-placer = new ClumpPlacer(120, 0.3, 0.06, 1);
-var terrainPainter = new TerrainPainter(tDune);
-painter = new SmoothElevationPainter(ELEVATION_MODIFY, 18, 30);
-createAreas( placer, [terrainPainter, painter],
-			avoidClasses(clPlayer, 10, clBaseResource, 6),
-			scaleByMapSize(15, 50)
-			);
+createAreas(
+	new ClumpPlacer(120, 0.3, 0.06, 1),
+	[
+		new TerrainPainter(tDune),
+		new SmoothElevationPainter(ELEVATION_MODIFY, 18, 30)
+	],
+	avoidClasses(clPlayer, 10, clBaseResource, 6),
+	scaleByMapSize(15, 50));
 
 log("Creating actual oasis...");
-var size = mapSize * 0.2;
-size *= size;
-//var lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 6))));
-fx = fractionToTiles(0.5);
-fz = fractionToTiles(0.5);
-ix = round(fx);
-iz = round(fz);
-placer = new ClumpPlacer(size*1.1, 0.8, 0.2, 10, ix, iz);
-terrainPainter = new LayeredPainter( [pOasisForestLight,tShoreBlend, tWater, tWater, tWater], [scaleByMapSize(6,20),3, 5, 2] );
-var elevationPainter = new SmoothElevationPainter(ELEVATION_SET,  -3,  15 );
-createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], null);
+var fx = fractionToTiles(0.5);
+var fz = fractionToTiles(0.5);
+createArea(
+	new ClumpPlacer(Math.pow(mapSize * 0.2, 2) * 1.1, 0.8, 0.2, 10, Math.round(fx), Math.round(fz)),
+	[
+		new LayeredPainter([pOasisForestLight,tShoreBlend, tWater, tWater, tWater], [scaleByMapSize(6, 20), 3, 5, 2]),
+		new SmoothElevationPainter(ELEVATION_SET, -3, 15),
+		paintClass(clWater)
+	],
+	null);
 RMS.SetProgress(50);
+
 if (mapSize > 150 && randBool())
 {
-	log ("creating path through");
+	log("Creating path though the oasis...");
 	var pAngle = randFloat(0, TWO_PI);
 	var px = round(fx) + round(fractionToTiles(0.13 * cos(pAngle)));
 	var py = round(fz) + round(fractionToTiles(0.13 * sin(pAngle)));
 	var pex = round(fx) + round(fractionToTiles(0.13 * -cos(pAngle)));
 	var pey = round(fz) + round(fractionToTiles(0.13 * sin(pAngle + PI)));
-	var path = new PathPlacer(px,py,pex,pey,scaleByMapSize(7,18), 0.4, 1, 0.2, 0);
-	terrainPainter = new TerrainPainter(tSand);
-	elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, 4, 5 );
-	createArea(path, [terrainPainter, elevationPainter, paintClass(clPassage)], null);
+	createArea(
+		new PathPlacer(px, py, pex, pey, scaleByMapSize(7, 18), 0.4, 1, 0.2, 0),
+		[
+			new TerrainPainter(tSand),
+			new SmoothElevationPainter(ELEVATION_MODIFY, 4, 5),
+			paintClass(clPassage)
+		],
+		null);
 }
 log("Creating some straggler trees around the Passage...");
-group = new SimpleGroup([new SimpleObject(ePalmTall, 1,1, 0,0),new SimpleObject(ePalmShort, 1,2, 1,2), new SimpleObject(aBushA, 0,2, 1,3)], true, clForest);
-createObjectGroupsDeprecated(group, 0, stayClasses(clPassage,1), scaleByMapSize(60,250), 100  );
+var group = new SimpleGroup([new SimpleObject(ePalmTall, 1,1, 0,0),new SimpleObject(ePalmShort, 1, 2, 1, 2), new SimpleObject(aBushA, 0,2, 1,3)], true, clForest);
+createObjectGroupsDeprecated(group, 0, stayClasses(clPassage, 1), scaleByMapSize(60, 250), 100);
 
 log("Creating stone mines...");
 group = new SimpleGroup([new SimpleObject(eStoneMine, 1,1, 0,0),new SimpleObject(ePalmShort, 1,2, 3,3),new SimpleObject(ePalmTall, 0,1, 3,3)
@@ -259,8 +290,6 @@ RMS.SetProgress(85);
 log("Creating Oasis Animals...");
 for (var p = 0; p < scaleByMapSize(5,30); p++)
 {
-	fx = fractionToTiles(0.5);
-	fz = fractionToTiles(0.5);
 	var aAngle = randFloat(0, TWO_PI);
 	var aDist = fractionToTiles(0.11);
 	var animX = round(fx + aDist * cos(aAngle));
@@ -269,21 +298,8 @@ for (var p = 0; p < scaleByMapSize(5,30); p++)
 		[new SimpleObject(eLion, 1,2, 0,4),new SimpleObject(eLioness, 1,2, 2,4),new SimpleObject(eGazelle, 4,6, 1,5),new SimpleObject(eCamel, 1,2, 1,5)], true, clFood, animX,animY);
 	createObjectGroup(group, 0);
 }
-/*
-var planetm = 8;
-log("Creating small grass tufts...");
-group = new SimpleGroup(
-	[new SimpleObject(rba1, 1,2, 0,1, -PI/8,PI/8)]
-);
-createObjectGroupsDeprecated(group, 0,
-	avoidClasses(clWater, 2, clHill, 2, clPlayer, 2, clDirt, 0),
-	planetm * scaleByMapSize(13, 200)
-);
-*/
 RMS.SetProgress(90);
 
-RMS.SetProgress(95);
-
 log("Creating bushes...");
 group = new SimpleGroup(
 	[new SimpleObject(aBushB, 1,2, 0,2), new SimpleObject(aBushA, 2,4, 0,2)]
@@ -303,7 +319,8 @@ for (var sandx = 0; sandx < mapSize; sandx += 4)
 				group = new SimpleGroup( [new SimpleObject(aSand, 0,1, 0,2)], true, undefined, sandx,sandz );
 				createObjectGroup(group, 0);
 			}
-		} else if (getHeight(sandx,sandz) > -2.5 && getHeight(sandx,sandz) < -1.0)
+		}
+		else if (getHeight(sandx, sandz) > -2.5 && getHeight(sandx,sandz) < -1)
 		{
 			if (randBool(0.4))
 			{
diff --git a/binaries/data/mods/public/maps/random/persian_highlands.js b/binaries/data/mods/public/maps/random/persian_highlands.js
index 43a7764bf5..1c3457b79a 100644
--- a/binaries/data/mods/public/maps/random/persian_highlands.js
+++ b/binaries/data/mods/public/maps/random/persian_highlands.js
@@ -148,49 +148,63 @@ for (var i = 0; i < numPlayers; i++)
 RMS.SetProgress(10);
 
 log("Creating rock patches...");
-placer = new ChainPlacer(1, floor(scaleByMapSize(3, 6)), floor(scaleByMapSize(20, 45)), 0);
-painter = new TerrainPainter(tRocky);
-createAreas(placer, [painter, paintClass(clPatch)],
+createAreas(
+	new ChainPlacer(1, Math.floor(scaleByMapSize(3, 6)), Math.floor(scaleByMapSize(20, 45)), 0),
+	[
+		new TerrainPainter(tRocky),
+		paintClass(clPatch)
+	],
 	avoidClasses(clPatch, 2, clPlayer, 0),
-	scaleByMapSize(5, 20)
-);
-
+	scaleByMapSize(5, 20));
 RMS.SetProgress(15);
 
-var placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), floor(scaleByMapSize(15, 40)), 0);
-var painter = new TerrainPainter([tRocky, tRocks]);
-createAreas(placer, [painter, paintClass(clPatch)],
+log("Creating secondary rock patches...");
+createAreas(
+	new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), Math.floor(scaleByMapSize(15, 40)), 0),
+	[
+		new TerrainPainter([tRocky, tRocks]),
+		paintClass(clPatch)
+	],
 	avoidClasses(clPatch, 2, clPlayer, 4),
-	scaleByMapSize(15, 50)
-);
-
+	scaleByMapSize(15, 50));
 RMS.SetProgress(20);
 
 log("Creating dirt patches...");
-placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), floor(scaleByMapSize(15, 40)), 0);
-painter = new TerrainPainter([tGrass]);
-createAreas(placer, [painter, paintClass(clPatch)],
+createAreas(
+	new ChainPlacer(
+		1,
+		Math.floor(scaleByMapSize(3, 5)),
+		Math.floor(scaleByMapSize(15, 40)),
+		0),
+	[
+		new TerrainPainter([tGrass]),
+		paintClass(clPatch)
+	],
 	avoidClasses(clPatch, 2, clPlayer, 4),
-	scaleByMapSize(15, 50)
-);
-
+	scaleByMapSize(15, 50));
 RMS.SetProgress(25);
 
 log("Creating centeral plateau...");
-var halfSize = mapSize / 2;
-var oRadius = scaleByMapSize(18, 68);
-placer = new ChainPlacer(2, floor(scaleByMapSize(5, 13)), floor(scaleByMapSize(35, 200)), 1, halfSize, halfSize, 0, [floor(oRadius)]);
-painter = new LayeredPainter([tLakebed2, tLakebed1], [6]);
-var elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, -10, 8);
-createArea(placer, [painter, elevationPainter, paintClass(clCP)], avoidClasses(clPlayer, 18));
-
+createArea(
+	new ChainPlacer(
+		2,
+		Math.floor(scaleByMapSize(5, 13)),
+		Math.floor(scaleByMapSize(35, 200)),
+		1,
+		mapSize / 2,
+		mapSize / 2,
+		0,
+		[Math.floor(scaleByMapSize(18, 68))]),
+	[
+		new LayeredPainter([tLakebed2, tLakebed1], [6]),
+		new SmoothElevationPainter(ELEVATION_MODIFY, -10, 8),
+		paintClass(clCP)
+	],
+	avoidClasses(clPlayer, 18));
 RMS.SetProgress(30);
 
 log("Creating hills...");
-var numHills = scaleByMapSize(20, 80);
-for (var i = 0; i < numHills; ++i)
-{
-
+for (let i = 0; i < scaleByMapSize(20, 80); ++i)
 	createMountain(
 		floor(scaleByMapSize(40, 60)),
 		floor(scaleByMapSize(3, 4)),
@@ -201,10 +215,7 @@ for (var i = 0; i < numHills; ++i)
 		randIntExclusive(0, mapSize),
 		tCliff,
 		clHill,
-		14
-	);
-}
-
+		14);
 RMS.SetProgress(35);
 
 // calculate desired number of trees for map (based on size)
@@ -220,27 +231,30 @@ log("Creating forests...");
 var types = [
 	[[tDirtMain, tForestFloor, pForestO], [tForestFloor, pForestO]],
 	[[tDirtMain, tForestFloor, pForestO], [tForestFloor, pForestO]]
-];	// some variation
+];
 var size = numForest / (scaleByMapSize(3,6) * numPlayers);
 var num = floor(size / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	placer = new ChainPlacer(floor(scaleByMapSize(1, 2)), floor(scaleByMapSize(2, 5)), floor(size / floor(scaleByMapSize(8, 3))), 1);
-	painter = new LayeredPainter(
-		types[i],		// terrains
-		[2]											// widths
-		);
+for (let type of types)
 	createAreas(
-		placer,
-		[painter, paintClass(clForest)],
-		avoidClasses(clPlayer, 6, clForest, 10, clHill, 1, clCP, 1),
-		num
-	);
-}
+		new ChainPlacer(
+			Math.floor(scaleByMapSize(1, 2)),
+			Math.floor(scaleByMapSize(2, 5)),
+			Math.floor(size / Math.floor(scaleByMapSize(8, 3))),
+			1),
+		[
+			new LayeredPainter(type, [2]),
+			paintClass(clForest)
+		],
+		avoidClasses(
+			clPlayer, 6,
+			clForest, 10,
+			clHill, 1,
+			clCP, 1),
+		num);
 RMS.SetProgress(50);
 
 log("Creating stone mines...");
-group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4), new RandomObject(aBushes, 2,4, 0,2)], true, clRock);
+var group = new SimpleGroup([new SimpleObject(oStoneSmall, 0, 2, 0, 4), new SimpleObject(oStoneLarge, 1, 1, 0, 4), new RandomObject(aBushes, 2, 4, 0, 2)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 10, clRock, 10, clHill, 1, clCP, 1)],
 	scaleByMapSize(2,8), 100
@@ -352,19 +366,24 @@ createObjectGroupsDeprecated(group, 0,
 RMS.SetProgress(90);
 
 log("Creating straggler trees...");
-var types = [oOak];	// some variation
+var types = [oOak];
 var num = floor(numStragglers / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	group = new SimpleGroup(
-		[new SimpleObject(types[i], 1,1, 0,3)],
-		true, clForest
-	);
-	createObjectGroupsDeprecated(group, 0,
-		avoidClasses(clForest, 1, clHill, 1, clPlayer, 1, clMetal, 6, clRock, 6, clCP, 2),
-		num
-	);
-}
+for (let type of types)
+	createObjectGroupsDeprecated(
+		new SimpleGroup(
+			[new SimpleObject(type, 1, 1, 0, 3)],
+			true,
+			clForest),
+		0,
+		avoidClasses(
+			clForest, 1,
+			clHill, 1,
+			clPlayer, 1,
+			clBaseResource, 6,
+			clMetal, 6,
+			clRock, 6,
+			clCP, 2),
+		num);
 
 setSunColor(1.0, 0.796, 0.374);
 setSunElevation(PI / 6);
diff --git a/binaries/data/mods/public/maps/random/phoenician_levant.js b/binaries/data/mods/public/maps/random/phoenician_levant.js
index cdf7fc045d..ef7b415d92 100644
--- a/binaries/data/mods/public/maps/random/phoenician_levant.js
+++ b/binaries/data/mods/public/maps/random/phoenician_levant.js
@@ -163,28 +163,22 @@ paintRiver({
 RMS.SetProgress(40);
 
 log("Creating bumps...");
-placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1);
-painter = new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2);
 createAreas(
-	placer,
-	painter,
+	new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1),
+	new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2),
 	avoidClasses(clWater, 2, clPlayer, 20),
-	scaleByMapSize(100, 200)
-);
+	scaleByMapSize(100, 200));
 
 log("Creating hills...");
-placer = new ChainPlacer(1, floor(scaleByMapSize(4, 6)), floor(scaleByMapSize(16, 40)), 0.5);
-var terrainPainter = new LayeredPainter(
-	[tCliff, tHill],		// terrains
-	[2]								// widths
-);
-var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 15, 2);
 createAreas(
-	placer,
-	[terrainPainter, elevationPainter, paintClass(clHill)],
+	new ChainPlacer(1, Math.floor(scaleByMapSize(4, 6)), Math.floor(scaleByMapSize(16, 40)), 0.5),
+	[
+		new LayeredPainter([tCliff, tHill], [2]),
+		new SmoothElevationPainter(ELEVATION_SET, 15, 2),
+		paintClass(clHill)
+	],
 	avoidClasses(clPlayer, 20, clForest, 1, clHill, 15, clWater, 0),
-	scaleByMapSize(1, 4) * numPlayers * 3
-);
+	scaleByMapSize(1, 4) * numPlayers * 3);
 
 // calculate desired number of trees for map (based on size)
 const MIN_TREES = 500;
@@ -197,66 +191,58 @@ var numStragglers = totalTrees * (1.0 - P_FOREST);
 
 log("Creating forests...");
 var num = scaleByMapSize(10,42);
-placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), numForest / (num * floor(scaleByMapSize(2,5))), 0.5);
-painter = new TerrainPainter([tForestFloor, pForest]);
-createAreas(placer, [painter, paintClass(clForest)],
+createAreas(
+	new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), numForest / (num * Math.floor(scaleByMapSize(2, 5))), 0.5),
+	[
+		new TerrainPainter([tForestFloor, pForest]),
+		paintClass(clForest)
+	],
 	avoidClasses(clPlayer, 20, clForest, 10, clWater, 1, clHill, 1, clBaseResource, 3),
-	num, 50
-);
+	num,
+	50);
 RMS.SetProgress(50);
 
 log("Creating grass patches...");
-var sizes = [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)];
-for (var i = 0; i < sizes.length; i++)
-{
-	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
-	painter = new LayeredPainter(
-		[[tGrass,tRocksShrubs],[tRocksShrubs,tRocksGrass], [tRocksGrass,tGrass]], 		// terrains
-		[1,1]															// widths
-	);
+for (let size of [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)])
 	createAreas(
-		placer,
-		[painter, paintClass(clDirt)],
+		new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
+		[
+			new LayeredPainter(
+				[[tGrass, tRocksShrubs], [tRocksShrubs, tRocksGrass], [tRocksGrass, tGrass]],
+				[1, 1]),
+			paintClass(clDirt)
+		],
 		avoidClasses(clForest, 0, clGrass, 5, clPlayer, 10, clWater, 4, clDirt, 5, clHill, 1),
-		scaleByMapSize(15, 45)
-	);
-}
+		scaleByMapSize(15, 45));
 RMS.SetProgress(55);
 
 log("Creating dirt patches...");
-var sizes = [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)];
-for (var i = 0; i < sizes.length; i++)
-{
-	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
-	painter = new LayeredPainter(
-		[[tDirt,tDirtB],[tDirt,tMainDirt], [tDirtB,tMainDirt]], 		// terrains
-		[1,1]															// widths
-	);
+for (let size of [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)])
 	createAreas(
-		placer,
-		[painter, paintClass(clDirt)],
+		new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
+		[
+			new LayeredPainter(
+				[[tDirt, tDirtB], [tDirt, tMainDirt], [tDirtB, tMainDirt]],
+				[1, 1]),
+			paintClass(clDirt)
+		],
 		avoidClasses(clForest, 0, clDirt, 5, clPlayer, 10, clWater, 4, clGrass, 5, clHill, 1),
-		scaleByMapSize(15, 45)
-	);
-}
+		scaleByMapSize(15, 45));
 RMS.SetProgress(60);
 
 log("Creating cyprus...");
-placer = new ClumpPlacer(4.5 * scaleByMapSize(60, 540), 0.2, 0.1, 0.01);
-var terrainPainter = new LayeredPainter(
-	[tShore, tHill],		// terrains
-	[12]								// widths
-);
-var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 6, 8);
 createAreas(
-	placer,
-	[terrainPainter, elevationPainter, paintClass(clIsland)],
+	new ClumpPlacer(4.5 * scaleByMapSize(60, 540), 0.2, 0.1, 0.01),
+	[
+		new LayeredPainter([tShore, tHill], [12]),
+		new SmoothElevationPainter(ELEVATION_SET, 6, 8),
+		paintClass(clIsland)
+	],
 	[stayClasses (clWater, 5)],
-	1
-);
+	1);
 
 log("Creating cyprus stone mines...");
-group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
+var group = new SimpleGroup([new SimpleObject(oStoneSmall, 0, 2, 0, 4), new SimpleObject(oStoneLarge, 1, 1, 0, 4)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	stayClasses(clIsland, 9),
 	14 * scaleByMapSize(4,16), 100
@@ -362,27 +348,16 @@ createObjectGroupsDeprecated(group, 0,
 RMS.SetProgress(90);
 
 log("Creating straggler trees...");
-var types = [oDatePalm, oSDatePalm, oCarob, oFanPalm, oPoplar, oCypress];	// some variation
-var num = floor(numStragglers / types.length);
-for (var i = 0; i < types.length; ++i)
+var types = [oDatePalm, oSDatePalm, oCarob, oFanPalm, oPoplar, oCypress];
+var stragglerTrees = [
+	[1, avoidClasses(clForest, 0, clWater, 1, clPlayer, 8, clMetal, 6, clHill, 1)],
+	[3, stayClasses(clIsland, 9)]
+];
+for (let [amount, constraint] of stragglerTrees)
 {
-	group = new SimpleGroup([new SimpleObject(types[i], 1,1, 0,0)], true);
-	createObjectGroupsDeprecated(group, 0,
-		avoidClasses(clForest, 0, clWater, 1, clPlayer, 8, clMetal, 6, clHill, 1),
-		num
-	);
-}
-
-log("Creating straggler trees...");
-var types = [oDatePalm, oSDatePalm, oCarob, oFanPalm, oPoplar, oCypress];	// some variation
-var num = 3*floor(numStragglers / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	group = new SimpleGroup([new SimpleObject(types[i], 1,1, 0,0)], true);
-	createObjectGroupsDeprecated(group, 0,
-		stayClasses(clIsland, 9),
-		num
-	);
+	let num = amount * Math.floor(numStragglers / types.length);
+	for (let type of types)
+		createObjectGroupsDeprecated(new SimpleGroup([new SimpleObject(type, 1, 1, 0, 0)], true), 0, constraint, num);
 }
 
 setSkySet("sunny");
diff --git a/binaries/data/mods/public/maps/random/polar_sea.js b/binaries/data/mods/public/maps/random/polar_sea.js
index 8cababc7c8..d483259415 100644
--- a/binaries/data/mods/public/maps/random/polar_sea.js
+++ b/binaries/data/mods/public/maps/random/polar_sea.js
@@ -117,26 +117,22 @@ for (let i = 0; i < numPlayers; ++i)
 RMS.SetProgress(30);
 
 log("Creating central lake...");
-var placer = new ChainPlacer(
-	2,
-	Math.floor(scaleByMapSize(5, 16)),
-	Math.floor(scaleByMapSize(35, 200)),
-	1,
-	Math.round(fractionToTiles(0.5)),
-	Math.round(fractionToTiles(0.5)),
-	0,
-	[Math.floor(mapSize * 0.17)]);
-
-var terrainPainter = new LayeredPainter(
-	[tShore, tWater, tWater, tWater],		// terrains
-	[1, 4, 2]		// widths
-);
-var elevationPainter = new SmoothElevationPainter(
-	ELEVATION_SET,			// type
-	-4,				// elevation
-	4				// blend radius
-);
-createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 20));
+createArea(
+	new ChainPlacer(
+		2,
+		Math.floor(scaleByMapSize(5, 16)),
+		Math.floor(scaleByMapSize(35, 200)),
+		1,
+		Math.round(fractionToTiles(0.5)),
+		Math.round(fractionToTiles(0.5)),
+		0,
+		[Math.floor(mapSize * 0.17)]),
+	[
+		new LayeredPainter([tShore, tWater, tWater, tWater], [1, 4, 2]),
+		new SmoothElevationPainter(ELEVATION_SET, -4, 4),
+		paintClass(clWater)
+	],
+	avoidClasses(clPlayer, 20));
 
 paintTerrainBasedOnHeight(3, Math.floor(scaleByMapSize(20, 40)), 0, tCliff);
 paintTerrainBasedOnHeight(Math.floor(scaleByMapSize(20, 40)), 100, 3, tSnowLimited);
@@ -158,25 +154,22 @@ for (let i = 0; i < numLakes ; ++i)
 	if (!chosenPoint)
 		break;
 
-	placer = new ChainPlacer(
-		1,
-		Math.floor(scaleByMapSize(2, 4)),
-		Math.floor(scaleByMapSize(20, 140)),
-		0.7,
-		chosenPoint[0],
-		chosenPoint[1]);
-
-	let terrainPainter = new LayeredPainter(
-		[tShore, tWater, tWater],		// terrains
-		[1, 3]								// widths
-	);
-	let elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -5, 5);
 	createAreas(
-		placer,
-		[terrainPainter, elevationPainter, paintClass(clWater)],
+		new ChainPlacer(
+			1,
+			Math.floor(scaleByMapSize(2, 4)),
+			Math.floor(scaleByMapSize(20, 140)),
+			0.7,
+			chosenPoint[0],
+			chosenPoint[1]),
+		[
+			new LayeredPainter([tShore, tWater, tWater], [1, 3]),
+			new SmoothElevationPainter(ELEVATION_SET, -5, 5),
+			paintClass(clWater)
+		],
 		avoidClasses(clPlayer, 20),
-		1, 1
-	);
+		1,
+		1);
 }
 RMS.SetProgress(50);
 
@@ -195,15 +188,13 @@ createLayeredPatches(
 	[scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
 	[[tDirt,tHalfSnow], [tHalfSnow,tSnowLimited]],
 	[2],
-	avoidClasses(clWater, 3, clDirt, 5, clPlayer, 12)
-);
+	avoidClasses(clWater, 3, clDirt, 5, clPlayer, 12));
 
 log("Creating glacier patches...");
 createPatches(
 	[scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
 	tSecondary,
-	avoidClasses(clWater, 3, clDirt, 5, clPlayer, 12)
-);
+	avoidClasses(clWater, 3, clDirt, 5, clPlayer, 12));
 RMS.SetProgress(70);
 
 log("Creating stone mines...");
@@ -221,8 +212,7 @@ createMines(
 		[new SimpleObject(oMetalLarge, 1,1, 0,4)]
 	],
 	avoidClasses(clWater, 3, clPlayer, 20, clMetal, 18, clRock, 5, clHill, 2),
-	clMetal
-);
+	clMetal);
 RMS.SetProgress(75);
 
 createDecoration(
@@ -237,8 +227,7 @@ createDecoration(
 		scaleByMapSize(16, 262),
 		scaleByMapSize(8, 131),
 	],
-	avoidClasses(clWater, 0, clPlayer, 0)
-);
+	avoidClasses(clWater, 0, clPlayer, 0));
 
 createDecoration(
 	[
@@ -247,8 +236,7 @@ createDecoration(
 	[
 		scaleByMapSize(8, 131)
 	],
-	[stayClasses(clWater, 4), avoidClasses(clHill, 2)]
-);
+	[stayClasses(clWater, 4), avoidClasses(clHill, 2)]);
 RMS.SetProgress(80);
 
 createFood(
@@ -296,8 +284,7 @@ createObjectGroupsDeprecated(
 	0,
 	avoidClasses(clWater, 2, clMetal, 4, clRock, 4, clPlayer, 15, clHill, 2, clWolf, 20),
 	1000,
-	100
-);
+	100);
 RMS.SetProgress(95);
 
 if (randBool(1/3))
diff --git a/binaries/data/mods/public/maps/random/pyrenean_sierra.js b/binaries/data/mods/public/maps/random/pyrenean_sierra.js
index 5ffe3f7dad..74154f7fbb 100644
--- a/binaries/data/mods/public/maps/random/pyrenean_sierra.js
+++ b/binaries/data/mods/public/maps/random/pyrenean_sierra.js
@@ -469,20 +469,24 @@ log ("creating Oceans");
 var OceanX = fractionToTiles(0.5) + cos(MoutainAngle + lololo)*fractionToTiles(0.48);
 var OceanZ = fractionToTiles(0.5) + sin(MoutainAngle + lololo)*fractionToTiles(0.48);
 
-var radius = fractionToTiles(0.18);
-var size = radius*radius*PI;
-var placer = new ClumpPlacer(size, 0.9, 0.05, 10, OceanX, OceanZ);
-var elevationPainter = new ElevationPainter(-22);
-createArea(placer, [paintClass(clWater),elevationPainter], null);
+createArea(
+	new ClumpPlacer(Math.PI * Math.pow(fractionToTiles(0.18), 2), 0.9, 0.05, 10, OceanX, OceanZ),
+	[
+		paintClass(clWater),
+		new ElevationPainter(-22)
+	],
+	null);
 
 OceanX = fractionToTiles(0.5) + cos(PI + MoutainAngle + lololo)*fractionToTiles(0.48);
 OceanZ = fractionToTiles(0.5) + sin(PI + MoutainAngle + lololo)*fractionToTiles(0.48);
 
-radius = fractionToTiles(0.18);
-size = radius*radius*PI;
-placer = new ClumpPlacer(size, 0.9, 0.05, 10, OceanX, OceanZ);
-elevationPainter = new ElevationPainter(-22);
-createArea(placer, [paintClass(clWater),elevationPainter], null);
+createArea(
+	new ClumpPlacer(Math.PI * Math.pow(fractionToTiles(0.18), 2), 0.9, 0.05, 10, OceanX, OceanZ),
+	[
+		new ElevationPainter(-22),
+		paintClass(clWater)
+	],
+	null);
 
 // Smoothing around the water, then going a bit random
 for (var ix = 1; ix < mapSize-1; ix++)
@@ -523,23 +527,29 @@ for (var ix = 1; ix < mapSize-1; ix++)
 }
 RMS.SetProgress(55);
 
-//create hills
 log ("Creating hills...");
-placer = new ClumpPlacer(scaleByMapSize(60, 120), 0.3, 0.06, 5);
-painter = new SemiRandomElevationPainter(7, 4,1);
-var terrainPainter = new TerrainPainter(tGrassSpecific);
-createAreas( placer, [painter,terrainPainter, paintClass(clHill)],  avoidClasses(clWater, 5, clPlayer, 20, clBaseResource, 6, clPyrenneans, 2), scaleByMapSize(5, 35) );
+createAreas(
+	new ClumpPlacer(scaleByMapSize(60, 120), 0.3, 0.06, 5),
+	[
+		new SemiRandomElevationPainter(7, 4, 1),
+		new TerrainPainter(tGrassSpecific),
+		paintClass(clHill)
+	],
+	avoidClasses(clWater, 5, clPlayer, 20, clBaseResource, 6, clPyrenneans, 2), scaleByMapSize(5, 35));
 
 log("Creating forests...");
-var types = [ [tForestTransition,pForestLandVeryLight, pForestLandLight, pForestLand]];
+var types = [[tForestTransition, pForestLandVeryLight, pForestLandLight, pForestLand]];
 var size = scaleByMapSize(40,115)*PI;
 var num = floor(scaleByMapSize(8,40) / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	placer = new ClumpPlacer(size, 0.2, 0.1, 1);
-	painter = new LayeredPainter( types[i], [scaleByMapSize(1,2),scaleByMapSize(3,6),scaleByMapSize(3,6)] );
-	createAreas( placer, [painter, paintClass(clForest)], avoidClasses(clPlayer, 20, clPyrenneans,0, clForest, 7, clWater, 2), num);
-}
+for (let type of types)
+	createAreas(
+		new ClumpPlacer(size, 0.2, 0.1, 1),
+		[
+			new LayeredPainter(type, [scaleByMapSize(1, 2), scaleByMapSize(3, 6), scaleByMapSize(3, 6)]),
+			paintClass(clForest)
+		],
+		avoidClasses(clPlayer, 20, clPyrenneans,0, clForest, 7, clWater, 2),
+		num);
 RMS.SetProgress(60);
 
 log("Creating lone trees...");
@@ -620,22 +630,26 @@ for (var x = 0; x < mapSize; x++) {
 	}
 }
 log("Creating dirt patches...");
-var sizes = [scaleByMapSize(3, 20), scaleByMapSize(5, 40), scaleByMapSize(8, 60)];
-for (var i = 0; i < sizes.length; i++)
-{
-	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
-	painter = new TerrainPainter(tDirtyGrass);
-	createAreas( placer, [painter, paintClass(clDirt)], avoidClasses(clWater, 3, clForest, 0, clPyrenneans,5, clHill, 0, clDirt, 5, clPlayer, 6), scaleByMapSize(15, 45) );
-}
+for (let size of [scaleByMapSize(3, 20), scaleByMapSize(5, 40), scaleByMapSize(8, 60)])
+	createAreas(
+		new ClumpPlacer(size, 0.3, 0.06, 0.5),
+		[
+			new TerrainPainter(tDirtyGrass),
+			paintClass(clDirt)
+		],
+		avoidClasses(clWater, 3, clForest, 0, clPyrenneans,5, clHill, 0, clDirt, 5, clPlayer, 6),
+		scaleByMapSize(15, 45));
 
 log("Creating grass patches...");
-var sizes = [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)];
-for (var i = 0; i < sizes.length; i++)
-{
-	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
-	painter = new TerrainPainter(tLushGrass);
-	createAreas( placer, [painter,paintClass(clLush)], avoidClasses(clWater, 3, clForest, 0, clPyrenneans,5, clHill, 0, clDirt, 5, clPlayer, 6), scaleByMapSize(15, 45) );
-}
+for (let size of [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)])
+	createAreas(
+		new ClumpPlacer(size, 0.3, 0.06, 0.5),
+		[
+			new TerrainPainter(tLushGrass),
+			paintClass(clLush)
+		],
+		avoidClasses(clWater, 3, clForest, 0, clPyrenneans,5, clHill, 0, clDirt, 5, clPlayer, 6),
+		scaleByMapSize(15, 45));
 
 RMS.SetProgress(70);
 
diff --git a/binaries/data/mods/public/maps/random/rhine_marshlands.js b/binaries/data/mods/public/maps/random/rhine_marshlands.js
index 9bff01e3c0..4a8fab8df0 100644
--- a/binaries/data/mods/public/maps/random/rhine_marshlands.js
+++ b/binaries/data/mods/public/maps/random/rhine_marshlands.js
@@ -130,53 +130,38 @@ for (var i = 0; i < numPlayers; i++)
 RMS.SetProgress(15);
 
 log("Creating bumps...");
-placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1);
-painter = new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2);
 createAreas(
-	placer,
-	painter,
+	new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1),
+	new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2),
 	avoidClasses(clPlayer, 13),
-	scaleByMapSize(300, 800)
-);
+	scaleByMapSize(300, 800));
 
 log("Creating marshes...");
-for (var i = 0; i < 7; i++)
-{
-	placer = new ChainPlacer(1, floor(scaleByMapSize(6, 12)), floor(scaleByMapSize(15, 60)), 0.8);
-	var terrainPainter = new LayeredPainter(
-		[tShoreBlend, tShore, tWater],		// terrains
-		[1,1]							// widths
-	);
-	var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -2, 3);
-	var waterAreas = createAreas(
-		placer,
-		[terrainPainter, elevationPainter, paintClass(clWater)],
+for (let i = 0; i < 7; ++i)
+	createAreas(
+		new ChainPlacer(1, Math.floor(scaleByMapSize(6, 12)), Math.floor(scaleByMapSize(15, 60)), 0.8),
+		[
+			new LayeredPainter([tShoreBlend, tShore, tWater], [1, 1]),
+			new SmoothElevationPainter(ELEVATION_SET, -2, 3),
+			paintClass(clWater)
+		],
 		avoidClasses(clPlayer, 20, clWater, round(scaleByMapSize(7,16)*randFloat(0.8,1.35))),
-		scaleByMapSize(4,20)
-	);
-}
+		scaleByMapSize(4,20));
 
 log("Creating reeds...");
-group = new SimpleGroup(
-	[new SimpleObject(aReeds, 5,10, 0,4), new SimpleObject(aLillies, 5,10, 0,4)], true
-);
-createObjectGroupsDeprecated(group, 0,
+createObjectGroupsDeprecated(
+	new SimpleGroup([new SimpleObject(aReeds, 5, 10, 0, 4), new SimpleObject(aLillies, 5, 10, 0, 4)], true),
+	0,
 	stayClasses(clWater, 1),
-	scaleByMapSize(400,2000), 100
-);
-waterAreas = [];
-
+	scaleByMapSize(400,2000), 100);
 RMS.SetProgress(40);
 
 log("Creating bumps...");
-placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1);
-painter = new SmoothElevationPainter(ELEVATION_MODIFY, 1, 2);
 createAreas(
-	placer,
-	painter,
+	new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1),
+	new SmoothElevationPainter(ELEVATION_MODIFY, 1, 2),
 	stayClasses(clWater, 2),
-	scaleByMapSize(50, 100)
-);
+	scaleByMapSize(50, 100));
 
 // calculate desired number of trees for map (based on size)
 const MIN_TREES = 500;
@@ -191,45 +176,33 @@ log("Creating forests...");
 var types = [
 	[[tForestFloor, tGrass, pForestD], [tForestFloor, pForestD]],
 	[[tForestFloor, tGrass, pForestP], [tForestFloor, pForestP]]
-];	// some variation
+];
 var size = numForest / (scaleByMapSize(3,6) * numPlayers);
 var num = floor(size / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), numForest / (num * floor(scaleByMapSize(2,4))), 1);
-	painter = new LayeredPainter(
-		types[i],		// terrains
-		[2]											// widths
-		);
+for (let type of types)
 	createAreas(
-		placer,
-		[painter, paintClass(clForest)],
+		new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), numForest / (num * Math.floor(scaleByMapSize(2, 4))), 1),
+		[
+			new LayeredPainter(type, [2]),
+			paintClass(clForest)
+		],
 		avoidClasses(clPlayer, 20, clWater, 0, clForest, 10, clHill, 1),
-		num
-	);
-}
-
+		num);
 RMS.SetProgress(50);
 
 log("Creating mud patches...");
-var sizes = [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)];
-for (var i = 0; i < sizes.length; i++)
-{
-	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 1);
-	painter = new LayeredPainter(
-		[tGrassA, tGrassB, tMud], 		// terrains
-		[1,1]															// widths
-	);
+for (let size of [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)])
 	createAreas(
-		placer,
-		[painter, paintClass(clDirt)],
+		new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 1),
+		[
+			new LayeredPainter([tGrassA, tGrassB, tMud], [1, 1]),
+			paintClass(clDirt)
+		],
 		avoidClasses(clWater, 1, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 8),
-		scaleByMapSize(15, 45)
-	);
-}
+		scaleByMapSize(15, 45));
 
 log("Creating stone mines...");
-group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
+var group = new SimpleGroup([new SimpleObject(oStoneSmall, 0, 2, 0, 4), new SimpleObject(oStoneLarge, 1, 1, 0, 4)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clWater, 0, clForest, 1, clPlayer, 20, clRock, 10, clHill, 1)],
 	scaleByMapSize(4,16), 100
@@ -332,52 +305,53 @@ createObjectGroupsDeprecated(group, 0,
 RMS.SetProgress(80);
 
 log("Creating straggler trees...");
-var types = [oOak, oBeech];	// some variation
+var types = [oOak, oBeech];
 var num = floor(numStragglers / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	group = new SimpleGroup(
-		[new SimpleObject(types[i], 1,1, 0,3)],
-		true, clForest
-	);
-	createObjectGroupsDeprecated(group, 0,
+for (let type of types)
+	createObjectGroupsDeprecated(
+		new SimpleGroup(
+			[new SimpleObject(type, 1, 1, 0, 3)],
+			true,
+			clForest),
+		0,
 		avoidClasses(clForest, 1, clHill, 1, clPlayer, 13, clMetal, 6, clRock, 6, clWater, 0),
-		num
-	);
-}
+		num);
 
 RMS.SetProgress(85);
 
 log("Creating small grass tufts...");
-group = new SimpleGroup(
-	[new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)]
-);
-createObjectGroupsDeprecated(group, 0,
+createObjectGroupsDeprecated(
+	new SimpleGroup([new SimpleObject(aGrassShort, 1, 2, 0, 1)]),
+	0,
 	avoidClasses(clWater, 2, clHill, 2, clPlayer, 13, clDirt, 0),
-	scaleByMapSize(13, 200)
-);
+	scaleByMapSize(13, 200));
 
 RMS.SetProgress(90);
 
 log("Creating large grass tufts...");
-group = new SimpleGroup(
-	[new SimpleObject(aGrass, 2,4, 0,1.8, -PI/8,PI/8), new SimpleObject(aGrassShort, 3,6, 1.2,2.5, -PI/8,PI/8)]
-);
-createObjectGroupsDeprecated(group, 0,
+createObjectGroupsDeprecated(
+	new SimpleGroup(
+		[
+			new SimpleObject(aGrass, 2, 4, 0, 1.8),
+			new SimpleObject(aGrassShort, 3, 6, 1.2, 2.5)
+		]),
+	0,
 	avoidClasses(clWater, 3, clHill, 2, clPlayer, 13, clDirt, 1, clForest, 0),
-	scaleByMapSize(13, 200)
-);
+	scaleByMapSize(13, 200));
 
 RMS.SetProgress(95);
 
 log("Creating bushes...");
-group = new SimpleGroup(
-	[new SimpleObject(aBushMedium, 1,2, 0,2), new SimpleObject(aBushSmall, 2,4, 0,2)]
-);
-createObjectGroupsDeprecated(group, 0,
+createObjectGroupsDeprecated(
+	new SimpleGroup(
+		[
+			new SimpleObject(aBushMedium, 1, 2, 0, 2),
+			new SimpleObject(aBushSmall, 2, 4, 0, 2)
+		]),
+	0,
 	avoidClasses(clWater, 1, clHill, 1, clPlayer, 13, clDirt, 1),
-	scaleByMapSize(13, 200), 50
-);
+	scaleByMapSize(13, 200),
+	50);
 
 setSkySet("cirrus");
 setWaterColor(0.753,0.635,0.345);				// muddy brown
diff --git a/binaries/data/mods/public/maps/random/river_archipelago.js b/binaries/data/mods/public/maps/random/river_archipelago.js
index cff7c6e6fb..10b0934ab1 100644
--- a/binaries/data/mods/public/maps/random/river_archipelago.js
+++ b/binaries/data/mods/public/maps/random/river_archipelago.js
@@ -303,10 +303,9 @@ for (let type of types)
 RMS.SetProgress(60);
 
 log("Creating grass patches...");
-var sizes = [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)];
-for (let i = 0; i < sizes.length; ++i)
+for (let size of [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)])
 	createAreas(
-		new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), sizes[i], 0.5),
+		new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
 		[
 			new LayeredPainter([tGrassC, tGrassA, tGrassB], [2, 1]),
 			paintClass(clDirt)
@@ -321,10 +320,9 @@ for (let i = 0; i < sizes.length; ++i)
 		scaleByMapSize(20, 80));
 
 log("Creating dirt patches...");
-var sizes = [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)];
-for (let i = 0; i < sizes.length; ++i)
+for (let size of [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)])
 	createAreas(
-		new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), sizes[i], 0.5),
+		new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
 		[
 			new LayeredPainter([tPlants, tPlants], [1]),
 			paintClass(clDirt)
diff --git a/binaries/data/mods/public/maps/random/rivers.js b/binaries/data/mods/public/maps/random/rivers.js
index 7b2d3746d1..c6bd11526a 100644
--- a/binaries/data/mods/public/maps/random/rivers.js
+++ b/binaries/data/mods/public/maps/random/rivers.js
@@ -65,24 +65,20 @@ var clShallow = createTileClass();
 
 initTerrain(tMainTerrain);
 
-var fx = fractionToTiles(0.5);
-var fz = fractionToTiles(0.5);
-ix = round(fx);
-iz = round(fz);
-
-var lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 6))));
-
-var placer = new ClumpPlacer(mapArea * 0.01 * lSize, 0.7, 0.1, 10, ix, iz);
-var terrainPainter = new LayeredPainter(
-	[tShore, tWater, tWater, tWater],		// terrains
-	[1, 4, 2]		// widths
-);
-var elevationPainter = new SmoothElevationPainter(
-	ELEVATION_SET,			// type
-	-3,				// elevation
-	4				// blend radius
-);
-createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], null);
+createArea(
+	new ClumpPlacer(
+		mapArea / 100 * Math.pow(scaleByMapSize(1, 6), 1/8),
+		0.7,
+		0.1,
+		10,
+		Math.round(fractionToTiles(0.5)),
+		Math.round(fractionToTiles(0.5))),
+	[
+		new LayeredPainter([tShore, tWater, tWater, tWater], [1, 4, 2]),
+		new SmoothElevationPainter(ELEVATION_SET, -3, 4),
+		paintClass(clWater)
+	],
+	null);
 
 var [playerIDs, playerX, playerZ, playerAngle, startAngle] = radialPlayerPlacement();
 
@@ -104,7 +100,7 @@ for (var i = 0; i < numPlayers; i++)
 
 	// create the city patch
 	var cityRadius = radius/3;
-	placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
+	var placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tRoadWild, tRoad], [1]);
 	createArea(placer, painter, null);
 
@@ -236,13 +232,10 @@ for (var ix = 0; ix < mapSize; ix++)
 					var c = (PZ[m]*(PX[m]-PX[n]))-(PX[m]*(PZ[m]-PZ[n]));
 					var dis = abs(a*ix + b*iz + c)/sqrt(a*a + b*b);
 					if (abs(a*ix + b*iz + c) != 0)
-					{
 						var alamat = (a*ix + b*iz + c)/abs(a*ix + b*iz + c);
-					}
 					else
-					{
 						var alamat = 1;
-					}
+
 					var k = (a*ix + b*iz + c)/(a*a + b*b);
 					var y = iz-(b*k);
 					var xm = ix-(a*k);
@@ -261,9 +254,8 @@ for (var ix = 0; ix < mapSize; ix++)
 								addToClass(ix, iz, clShallow);
 							}
 							else
-							{
 								var h = -3;
-							}
+
 							var t = tWater;
 							addToClass(ix, iz, clWater);
 						}
@@ -279,23 +271,16 @@ for (var ix = 0; ix < mapSize; ix++)
 									addToClass(ix, iz, clShallow);
 								}
 								else
-								{
 									var h = 2-(sbms-dis);
-								}
 							}
 							else
-							{
 								var h = 2-(sbms-dis);
-							}
+
 							//we must create shore lines for more beautiful terrain
 							if (sbms-dis<=2)
-							{
 								var t = tShore;
-							}
 							else
-							{
 								var t = tWater;
-							}
 							addToClass(ix, iz, clWater);
 						}
 						//we don't want to cause problems when river joins sea
@@ -438,8 +423,9 @@ createFood
 
 RMS.SetProgress(85);
 
-var types = [oTree1, oTree2, oTree4, oTree3];	// some variation
-createStragglerTrees(types, avoidClasses(clWater, 5, clForest, 7, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6));
+createStragglerTrees(
+	[oTree1, oTree2, oTree4, oTree3],
+	avoidClasses(clWater, 5, clForest, 7, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6));
 
 setWaterWaviness(3.0);
 setWaterType("lake");
diff --git a/binaries/data/mods/public/maps/random/rmbiome/randombiome.js b/binaries/data/mods/public/maps/random/rmbiome/randombiome.js
index 6a02365380..76d0cf17e4 100644
--- a/binaries/data/mods/public/maps/random/rmbiome/randombiome.js
+++ b/binaries/data/mods/public/maps/random/rmbiome/randombiome.js
@@ -14,7 +14,7 @@ function currentBiome()
 
 function setSelectedBiome()
 {
-	setBiome(g_MapSettings.Biome);
+	setBiome(g_MapSettings.Biome || "alpine");
 }
 
 function setBiome(biomeID)
diff --git a/binaries/data/mods/public/maps/random/rmgen2/gaia.js b/binaries/data/mods/public/maps/random/rmgen2/gaia.js
index b27e95d5c4..a84824ad82 100644
--- a/binaries/data/mods/public/maps/random/rmgen2/gaia.js
+++ b/binaries/data/mods/public/maps/random/rmgen2/gaia.js
@@ -36,15 +36,15 @@ function addBluffs(constraint, size, deviation, fill, baseHeight)
 	{
 		var offset = getRandomDeviation(size, deviation);
 
-		var pMinSize = Math.floor(minSize * offset);
-		var pMaxSize = Math.floor(maxSize * offset);
-		var pSpread = Math.floor(spread * offset);
-		var pElevation = Math.floor(elevation * offset);
-
-		var placer = new ChainPlacer(pMinSize, pMaxSize, pSpread, 0.5);
-		var terrainPainter = new LayeredPainter([g_Terrains.cliff, g_Terrains.mainTerrain, constrastTerrain], [2, 3]);
-		var elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, pElevation, 2);
-		var rendered = createAreas(placer, [terrainPainter, elevationPainter, paintClass(g_TileClasses.bluff)], constraint, 1);
+		var rendered = createAreas(
+			new ChainPlacer(Math.floor(minSize * offset), Math.floor(maxSize * offset), Math.floor(spread * offset), 0.5),
+			[
+				new LayeredPainter([g_Terrains.cliff, g_Terrains.mainTerrain, constrastTerrain], [2, 3]),
+				new SmoothElevationPainter(ELEVATION_MODIFY, Math.floor(elevation * offset), 2),
+				paintClass(g_TileClasses.bluff)
+			],
+			constraint,
+			1);
 
 		// Find the bounding box of the bluff
 		if (rendered[0] === undefined)
@@ -388,19 +388,20 @@ function addElevation(constraint, el)
 		var pElevation = Math.floor(elevation * offset);
 
 		pElevation = Math.max(el.minElevation, Math.min(pElevation, el.maxElevation));
-
 		pMinSize = Math.min(pMinSize, pMaxSize);
 		pMaxSize = Math.min(pMaxSize, el.maxSize);
 		pMinSize = Math.max(pMaxSize, el.minSize);
-
 		pSmooth = Math.max(pSmooth, 1);
 
-		var pWidths = widths.concat(pSmooth);
-
-		var placer = new ChainPlacer(pMinSize, pMaxSize, pSpread, 0.5);
-		var terrainPainter = new LayeredPainter(el.painter, [pWidths]);
-		var elevationPainter = new SmoothElevationPainter(elType, pElevation, pSmooth);
-		createAreas(placer, [terrainPainter, elevationPainter, paintClass(el.class)], constraint, 1);
+		createAreas(
+			new ChainPlacer(pMinSize, pMaxSize, pSpread, 0.5),
+			[
+				new LayeredPainter(el.painter, [widths.concat(pSmooth)]),
+				new SmoothElevationPainter(elType, pElevation, pSmooth),
+				paintClass(el.class)
+			],
+			constraint,
+			1);
 	}
 }
 
@@ -488,34 +489,33 @@ function addLayeredPatches(constraint, size, deviation, fill)
 	var maxRadius = Math.floor(scaleByMapSize(3, 5));
 	var count = fill * scaleByMapSize(15, 45);
 
-	var sizes = [
+	var patchSizes = [
 		scaleByMapSize(3, 6),
 		scaleByMapSize(5, 10),
 		scaleByMapSize(8, 21)
 	];
 
-	for (var i = 0; i < sizes.length; ++i)
+	for (let patchSize of patchSizes)
 	{
 		var offset = getRandomDeviation(size, deviation);
 		var patchMinRadius = Math.floor(minRadius * offset);
 		var patchMaxRadius = Math.floor(maxRadius * offset);
-		var patchSize = Math.floor(sizes[i] * offset);
-		var patchCount = count * offset;
 
-		if (patchMinRadius > patchMaxRadius)
-			patchMinRadius = patchMaxRadius;
-
-		var placer = new ChainPlacer(patchMinRadius, patchMaxRadius, patchSize, 0.5);
-		var painter = new LayeredPainter(
+		createAreas(
+			new ChainPlacer(Math.min(patchMinRadius, patchMaxRadius), patchMaxRadius, Math.floor(patchSize * offset), 0.5),
 			[
-				[g_Terrains.mainTerrain, g_Terrains.tier1Terrain],
-				[g_Terrains.tier1Terrain, g_Terrains.tier2Terrain],
-				[g_Terrains.tier2Terrain, g_Terrains.tier3Terrain],
-				[g_Terrains.tier4Terrain]
+				new LayeredPainter(
+					[
+						[g_Terrains.mainTerrain, g_Terrains.tier1Terrain],
+						[g_Terrains.tier1Terrain, g_Terrains.tier2Terrain],
+						[g_Terrains.tier2Terrain, g_Terrains.tier3Terrain],
+						[g_Terrains.tier4Terrain]
+					],
+					[1, 1]),
+				paintClass(g_TileClasses.dirt)
 			],
-			[1, 1] // widths
-		);
-		createAreas(placer, [painter, paintClass(g_TileClasses.dirt)], constraint, patchCount);
+			constraint,
+			count * offset);
 	}
 }
 
@@ -573,24 +573,19 @@ function addPlateaus(constraint, size, deviation, fill)
 
 	for (var i = 0; i < 40; ++i)
 	{
-		var placer = new ChainPlacer(3, 15, 1, 0.5);
-		var terrainPainter = new LayeredPainter([plateauTile, plateauTile], [3]);
 		var hillElevation = randIntInclusive(4, 18);
-		var elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, hillElevation, hillElevation - 2);
-
 		createAreas(
-			placer,
+			new ChainPlacer(3, 15, 1, 0.5),
 			[
-				terrainPainter,
-				elevationPainter,
+				new LayeredPainter([plateauTile, plateauTile], [3]),
+				new SmoothElevationPainter(ELEVATION_MODIFY, hillElevation, hillElevation - 2),
 				paintClass(g_TileClasses.hill)
 			],
 			[
 				avoidClasses(g_TileClasses.hill, 7),
 				stayClasses(g_TileClasses.plateau, 7)
 			],
-			1
-		);
+			1);
 	}
 
 	addElements([
diff --git a/binaries/data/mods/public/maps/random/saharan_oases.js b/binaries/data/mods/public/maps/random/saharan_oases.js
index c285d8da20..3af9d955fc 100644
--- a/binaries/data/mods/public/maps/random/saharan_oases.js
+++ b/binaries/data/mods/public/maps/random/saharan_oases.js
@@ -131,55 +131,57 @@ for (var i = 0; i < numPlayers; i++)
 
 RMS.SetProgress(30);
 
-for (var i = 0; i < numPlayers; i++)
-{
-	log("Creating oases...");
-	var oRadius = scaleByMapSize(16, 60);
-	placer = new ClumpPlacer(PI*oRadius*oRadius*0.185, 0.6, 0.15, 0, mapSize*(0.5 + 0.18*cos(playerAngle[i]) + scaleByMapSize(1, 4)*cos(playerAngle[i])/100), mapSize*(0.5 + 0.18*sin(playerAngle[i]) + scaleByMapSize(1, 4)*sin(playerAngle[i])/100));
-	painter = new LayeredPainter([tSLush ,[tLush, pForest], [tLush, pForest], tShore, tShore, tWaterDeep], [2, 2, 1, 3, 1]);
-	var elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, -3, 10);
-	createArea(placer, [painter, elevationPainter, paintClass(clWater)], null);
-}
+log("Creating oases...");
+for (let i = 0; i < numPlayers; ++i)
+	createArea(
+		new ClumpPlacer(Math.PI * Math.pow(scaleByMapSize(16, 60), 2) * 0.185,
+			0.6,
+			0.15,
+			0,
+			mapSize * (0.5 + 0.18 * Math.cos(playerAngle[i]) + scaleByMapSize(1, 4) * Math.cos(playerAngle[i]) / 100),
+			mapSize * (0.5 + 0.18 * Math.sin(playerAngle[i]) + scaleByMapSize(1, 4) * Math.sin(playerAngle[i]) / 100)),
+		[
+			new LayeredPainter(
+				[tSLush ,[tLush, pForest], [tLush, pForest], tShore, tShore, tWaterDeep],
+				[2, 2, 1, 3, 1]),
+			new SmoothElevationPainter(ELEVATION_MODIFY, -3, 10),
+			paintClass(clWater)
+		],
+		null);
+RMS.SetProgress(50);
 
 log("Creating grass patches...");
-var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
-for (var i = 0; i < sizes.length; i++)
-{
-	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
-	painter = new LayeredPainter(
-		[[tDirt1,tSandDunes],[tSandDunes,tDirt2], [tDirt2,tDirt1]], 		// terrains
-		[1,1]															// widths
-	);
+for (let size of [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)])
 	createAreas(
-		placer,
-		[painter, paintClass(clDirt)],
+		new ClumpPlacer(size, 0.3, 0.06, 0.5),
+		[
+			new LayeredPainter(
+				[[tDirt1, tSandDunes], [tSandDunes, tDirt2], [tDirt2, tDirt1]],
+				[1, 1]
+			),
+			paintClass(clDirt)
+		],
 		avoidClasses(clForest, 0, clGrass, 5, clPlayer, 0, clWater, 1, clDirt, 5),
-		scaleByMapSize(15, 45)
-	);
-}
-
+		scaleByMapSize(15, 45));
 RMS.SetProgress(55);
 
 log("Creating dirt patches...");
-var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
-for (var i = 0; i < sizes.length; i++)
-{
-	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
-	painter = new LayeredPainter(
-		[[tDirt2,tDirtCracks],[tDirt2,tFineSand], [tDirtCracks,tFineSand]], 		// terrains
-		[1,1]															// widths
-	);
+for (let size of [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)])
 	createAreas(
-		placer,
-		[painter, paintClass(clDirt)],
+		new ClumpPlacer(size, 0.3, 0.06, 0.5),
+		[
+			new LayeredPainter(
+				[[tDirt2, tDirtCracks], [tDirt2, tFineSand], [tDirtCracks, tFineSand]],
+				[1, 1]
+			),
+			paintClass(clDirt)
+		],
 		avoidClasses(clForest, 0, clDirt, 5, clPlayer, 0, clWater, 1, clGrass, 5),
-		scaleByMapSize(15, 45)
-	);
-}
+		scaleByMapSize(15, 45));
 RMS.SetProgress(60);
 
 log("Creating stone mines...");
-group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
+var group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 1, clPlayer, 26, clRock, 10, clWater, 1),
 	2*scaleByMapSize(4,16), 100
diff --git a/binaries/data/mods/public/maps/random/sahel.js b/binaries/data/mods/public/maps/random/sahel.js
index 8e436f73c8..f2e3e37634 100644
--- a/binaries/data/mods/public/maps/random/sahel.js
+++ b/binaries/data/mods/public/maps/random/sahel.js
@@ -119,49 +119,31 @@ RMS.SetProgress(20);
 log("Creating big patches...");
 var patches = [tGrass2, tGrass3];
 for (var i = 0; i < patches.length; i++)
-{
-	placer = new ChainPlacer(floor(scaleByMapSize(3, 6)), floor(scaleByMapSize(10, 20)), floor(scaleByMapSize(15, 60)), 1);
-	painter = new TerrainPainter(patches[i]);
 	createAreas(
-		placer,
-		painter,
+		new ChainPlacer(Math.floor(scaleByMapSize(3, 6)), Math.floor(scaleByMapSize(10, 20)), Math.floor(scaleByMapSize(15, 60)), 1),
+		new TerrainPainter(patches[i]),
 		avoidClasses(clPlayer, 10),
-		scaleByMapSize(5, 20)
-	);
-}
+		scaleByMapSize(5, 20));
 
 log("Creating small patches...");
-var patches = [tDirt1, tDirt2, tDirt3];
-var sizes = [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)];
-for (var i = 0; i < sizes.length; i++)
-{
-	for (var j = 0; j < patches.length; ++j)
-	{
-		placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 1);
-		painter = new TerrainPainter(patches[j]);
+for (let size of [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)])
+	for (let patch of [tDirt1, tDirt2, tDirt3])
 		createAreas(
-			placer,
-			painter,
+			new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 1),
+			new TerrainPainter(patch),
 			avoidClasses(clPlayer, 12),
-			scaleByMapSize(4, 15)
-		);
-	}
-}
+			scaleByMapSize(4, 15));
 
 log("Creating water holes...");
-placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), floor(scaleByMapSize(20, 60)), 1);
-var terrainPainter = new LayeredPainter(
-	[tShore, tWater],		// terrains
-	[1]							// widths
-);
-var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -5, 7);
 createAreas(
-	placer,
-	[terrainPainter, elevationPainter, paintClass(clWater)],
+	new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), Math.floor(scaleByMapSize(20, 60)), 1),
+	[
+		new LayeredPainter([tShore, tWater], [1]),
+		new SmoothElevationPainter(ELEVATION_SET, -5, 7),
+		paintClass(clWater)
+	],
 	avoidClasses(clPlayer, 24),
-	scaleByMapSize(1, 3)
-);
-
+	scaleByMapSize(1, 3));
 RMS.SetProgress(55);
 
 var playerConstraint = new AvoidTileClassConstraint(clPlayer, 30);
@@ -181,7 +163,7 @@ for (var i = 0; i < scaleByMapSize(12,30); ++i)
 }
 
 log("Creating metal mines...");
-group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
+var group = new SimpleGroup([new SimpleObject(oMetalLarge, 1, 1, 0, 4)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clPlayer, 20, clMetal, 10, clRock, 8, clWater, 4),
 	scaleByMapSize(2,8), 100
diff --git a/binaries/data/mods/public/maps/random/sahel_watering_holes.js b/binaries/data/mods/public/maps/random/sahel_watering_holes.js
index bb6ef579d3..28406e9880 100644
--- a/binaries/data/mods/public/maps/random/sahel_watering_holes.js
+++ b/binaries/data/mods/public/maps/random/sahel_watering_holes.js
@@ -135,25 +135,52 @@ log ("Creating rivers...");
 for (var m = 0; m < numPlayers; m++)
 {
 	var tang = startAngle + (m + 0.5) * TWO_PI / numPlayers;
-	placer = new ClumpPlacer(floor(PI*scaleByMapSize(10,50)*scaleByMapSize(10,50)/3), 0.95, 0.6, 10, fractionToTiles(0.5 + 0.15*cos(tang)), fractionToTiles(0.5 + 0.15*sin(tang)));
-	var painter = new LayeredPainter([tShore, tWater, tWater], [1, 3]);
-	var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -4, 4);
-	createArea(placer, [painter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 5));
-	var placer = new PathPlacer(fractionToTiles(0.5 + 0.15*cos(tang)), fractionToTiles(0.5 + 0.15*sin(tang)), fractionToTiles(0.5 + 0.49*cos(tang)), fractionToTiles(0.5 + 0.49*sin(tang)), scaleByMapSize(10,50), 0.2, 3*(scaleByMapSize(1,4)), 0.2, 0.05);
-	var terrainPainter = new LayeredPainter(
-		[tShore, tWater, tWater],		// terrains
-		[1, 3]								// widths
-	);
-	var elevationPainter = new SmoothElevationPainter(
-		ELEVATION_SET,			// type
-		-4,				// elevation
-		4				// blend radius
-	);
-	createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 5));
-	placer = new ClumpPlacer(floor(PI*scaleByMapSize(10,50)*scaleByMapSize(10,50)/5), 0.95, 0.6, 10, fractionToTiles(0.5 + 0.49*cos(tang)), fractionToTiles(0.5 + 0.49*sin(tang)));
-	var painter = new LayeredPainter([tWater, tWater], [1]);
-	var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -4, 4);
-	createArea(placer, [painter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 5));
+
+	createArea(
+		new ClumpPlacer(
+			Math.floor(Math.PI * Math.pow(scaleByMapSize(10, 50), 2) / 3),
+			0.95,
+			0.6,
+			10,
+			fractionToTiles(0.5 + 0.15 * Math.cos(tang)),
+			fractionToTiles(0.5 + 0.15 * Math.sin(tang))),
+		[
+			new SmoothElevationPainter(ELEVATION_SET, -4, 4),
+			paintClass(clWater)
+		],
+		avoidClasses(clPlayer, 5));
+
+	createArea(
+		new PathPlacer(
+			fractionToTiles(0.5 + 0.15 * Math.cos(tang)),
+			fractionToTiles(0.5 + 0.15 * Math.sin(tang)),
+			fractionToTiles(0.5 + 0.49 * Math.cos(tang)),
+			fractionToTiles(0.5 + 0.49 * Math.sin(tang)),
+			scaleByMapSize(10, 50),
+			0.2,
+			3 * scaleByMapSize(1, 4),
+			0.2,
+			0.05),
+		[
+			new LayeredPainter([tShore, tWater, tWater], [1, 3]),
+			new SmoothElevationPainter(ELEVATION_SET, -4, 4),
+			paintClass(clWater)
+		],
+		avoidClasses(clPlayer, 5));
+
+	createArea(
+		new ClumpPlacer(
+			Math.floor(Math.PI * Math.pow(scaleByMapSize(10, 50), 2) / 5),
+			0.95,
+			0.6,
+			10,
+			fractionToTiles(0.5 + 0.49 * Math.cos(tang)),
+			fractionToTiles(0.5 + 0.49 * Math.sin(tang))),
+		[
+			new SmoothElevationPainter(ELEVATION_SET, -4, 4),
+			paintClass(clWater)
+		],
+		avoidClasses(clPlayer, 5));
 }
 
 for (var i = 0; i < numPlayers; i++)
@@ -179,7 +206,6 @@ for (var i = 0; i < numPlayers; i++)
 			true, clFood, round((fractionToTiles(playerX[i]) + fractionToTiles(playerX[0]))/2), round((fractionToTiles(playerZ[i]) + fractionToTiles(playerZ[0]))/2)
 		);
 		createObjectGroup(group, 0);
-
 	}
 	else
 	{
@@ -204,33 +230,26 @@ for (var i = 0; i < numPlayers; i++)
 		createObjectGroup(group, 0);
 
 	}
-
 }
 paintTerrainBasedOnHeight(-6, 2, 1, tWater);
 
 log("Creating bumps...");
-placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1);
-painter = new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2);
 createAreas(
-	placer,
-	painter,
+	new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1),
+	new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2),
 	avoidClasses(clWater, 2, clPlayer, 20),
-	scaleByMapSize(100, 200)
-);
+	scaleByMapSize(100, 200));
 
 log("Creating hills...");
-placer = new ClumpPlacer(scaleByMapSize(20, 150), 0.2, 0.1, 1);
-terrainPainter = new LayeredPainter(
-	[tGrass, tCliff, tHill],		// terrains
-	[1, 2]								// widths
-);
-elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 35, 3);
 createAreas(
-	placer,
-	[terrainPainter, elevationPainter, paintClass(clHill)],
+	new ClumpPlacer(scaleByMapSize(20, 150), 0.2, 0.1, 1),
+	[
+		new LayeredPainter([tGrass, tCliff, tHill], [1, 2]),
+		new SmoothElevationPainter(ELEVATION_SET, 35, 3),
+		paintClass(clHill)
+	],
 	avoidClasses(clPlayer, 20, clHill, 15, clWater, 3),
-	scaleByMapSize(1, 4) * numPlayers
-);
+	scaleByMapSize(1, 4) * numPlayers);
 
 // calculate desired number of trees for map (based on size)
 var MIN_TREES = 160;
@@ -244,61 +263,46 @@ var numStragglers = totalTrees * (1.0 - P_FOREST);
 log("Creating forests...");
 var types = [
 	[[tForestFloor, tGrass, pForest], [tForestFloor, pForest]]
-];	// some variation
+];
 
 var size = numForest / (0.5 * scaleByMapSize(2,8) * numPlayers);
 var num = floor(size / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	placer = new ClumpPlacer(numForest / num, 0.1, 0.1, 1);
-	painter = new LayeredPainter(
-		types[i],		// terrains
-		[2]											// widths
-		);
+for (let type of types)
 	createAreas(
-		placer,
-		[painter, paintClass(clForest)],
+		new ClumpPlacer(numForest / num, 0.1, 0.1, 1),
+		[
+			new LayeredPainter(type, [2]),
+			paintClass(clForest)
+		],
 		avoidClasses(clPlayer, 20, clForest, 10, clHill, 0, clWater, 2),
 		num
 	);
-}
-
 RMS.SetProgress(50);
 
 log("Creating dirt patches...");
-var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
-for (var i = 0; i < sizes.length; i++)
-{
-	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
-	painter = new LayeredPainter(
-		[[tGrass,tDirtRocksA],[tDirtRocksA,tDirtRocksB], [tDirtRocksB,tDirtRocksC]], 		// terrains
-		[1,1]															// widths
-	);
+for (let size of [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)])
 	createAreas(
-		placer,
-		[painter, paintClass(clDirt)],
+		new ClumpPlacer(size, 0.3, 0.06, 0.5),
+		[
+			new LayeredPainter(
+				[[tGrass, tDirtRocksA], [tDirtRocksA, tDirtRocksB], [tDirtRocksB, tDirtRocksC]],
+				[1, 1]),
+			paintClass(clDirt)
+		],
 		avoidClasses(clWater, 3, clForest, 0, clHill, 0, clPlayer, 20),
-		scaleByMapSize(15, 45)
-	);
-}
+		scaleByMapSize(15, 45));
 
 log("Creating grass patches...");
-var sizes = [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)];
-for (var i = 0; i < sizes.length; i++)
-{
-	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
-	painter = new TerrainPainter(tGrassPatch);
+for (let size of [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)])
 	createAreas(
-		placer,
-		painter,
+		new ClumpPlacer(size, 0.3, 0.06, 0.5),
+		new TerrainPainter(tGrassPatch),
 		avoidClasses(clWater, 3, clForest, 0, clHill, 0, clPlayer, 20),
-		scaleByMapSize(15, 45)
-	);
-}
+		scaleByMapSize(15, 45));
 RMS.SetProgress(55);
 
 log("Creating stone mines...");
-group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
+var group = new SimpleGroup([new SimpleObject(oStoneSmall, 0, 2, 0, 4), new SimpleObject(oStoneLarge, 1, 1, 0, 4)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clRock, 10, clHill, 1),
 	scaleByMapSize(4,16), 100
@@ -419,19 +423,14 @@ createObjectGroupsDeprecated(group, 0,
 RMS.SetProgress(85);
 
 log("Creating straggler trees...");
-var types = [oBaobab, oBaobab, oBaobab, oFig];	// some variation
+var types = [oBaobab, oBaobab, oBaobab, oFig];
 var num = floor(numStragglers / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	group = new SimpleGroup(
-		[new SimpleObject(types[i], 1,1, 0,3)],
-		true, clForest
-	);
-	createObjectGroupsDeprecated(group, 0,
+for (let type of types)
+	createObjectGroupsDeprecated(
+		new SimpleGroup([new SimpleObject(type, 1,1, 0,3)], true, clForest),
+		0,
 		avoidClasses(clWater, 5, clForest, 1, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6),
-		num
-	);
-}
+		num);
 
 var planetm = 4;
 log("Creating small grass tufts...");
diff --git a/binaries/data/mods/public/maps/random/schwarzwald.js b/binaries/data/mods/public/maps/random/schwarzwald.js
index 83fc4f7169..ad79da020c 100644
--- a/binaries/data/mods/public/maps/random/schwarzwald.js
+++ b/binaries/data/mods/public/maps/random/schwarzwald.js
@@ -362,15 +362,14 @@ createFood
 RMS.SetProgress(85);
 
 log("Planting reeds...");
-var types = [aReeds];	// some variation
-for (var i = 0; i < types.length; ++i)
-{
-	var group = new SimpleGroup([new SimpleObject(types[i], 1,1, 0,0)], true);
-	createObjectGroupsDeprecated(group, 0,
+var types = [aReeds];
+for (let type of types)
+	createObjectGroupsDeprecated(
+		new SimpleGroup([new SimpleObject(type, 1, 1, 0, 0)], true),
+		0,
 		borderClasses(clWater, 0, 6),
-		scaleByMapSize(960, 2000), 1000
-	);
-}
+		scaleByMapSize(1, 2) * 1000,
+		1000);
 
 RMS.SetProgress(90);
 
diff --git a/binaries/data/mods/public/maps/random/snowflake_searocks.js b/binaries/data/mods/public/maps/random/snowflake_searocks.js
index 418278f630..8f31e636c3 100644
--- a/binaries/data/mods/public/maps/random/snowflake_searocks.js
+++ b/binaries/data/mods/public/maps/random/snowflake_searocks.js
@@ -1611,28 +1611,19 @@ log("Creating forests...");
 var types = [
 	[[tForestFloor2, tMainTerrain, pForest1], [tForestFloor2, pForest1]],
 	[[tForestFloor1, tMainTerrain, pForest2], [tForestFloor1, pForest2]]
-];	// some variation
-
-if (currentBiome() == "savanna")
-	var size = numForest / (0.5 * scaleByMapSize(2,8) * numPlayers);
-else
-	var size = numForest / (scaleByMapSize(2,8) * numPlayers);
+];
 
+var size = numForest / scaleByMapSize(2, 8) * numPlayers * (currentBiome() == "savanna" ? 2 : 1);
 var num = floor(size / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	placer = new ClumpPlacer(numForest / num, 0.1, 0.1, 1);
-	painter = new LayeredPainter(
-		types[i],		// terrains
-		[2]											// widths
-		);
+for (let type of types)
 	createAreas(
-		placer,
-		[painter, paintClass(clForest)],
+		new ClumpPlacer(numForest / num, 0.1, 0.1, 1),
+		[
+			new LayeredPainter(type, [2]),
+			paintClass(clForest)
+		],
 		[avoidClasses(clPlayer, 6, clForest, 10, clHill, 0), stayClasses(clLand, 4)],
-		num
-	);
-}
+		num);
 RMS.SetProgress(55);
 
 log("Creating stone mines...");
@@ -1658,35 +1649,23 @@ createObjectGroupsDeprecated(group, 0,
 
 RMS.SetProgress(65);
 log("Creating dirt patches...");
-var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
-for (var i = 0; i < sizes.length; i++)
-{
-	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
-	painter = new LayeredPainter(
-		[[tMainTerrain,tTier1Terrain],[tTier1Terrain,tTier2Terrain], [tTier2Terrain,tTier3Terrain]], 		// terrains
-		[1,1]															// widths
-	);
+for (let size of [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)])
 	createAreas(
-		placer,
-		[painter, paintClass(clDirt)],
+		new ClumpPlacer(size, 0.3, 0.06, 0.5),
+		[
+			new LayeredPainter([[tMainTerrain, tTier1Terrain],[tTier1Terrain, tTier2Terrain], [tTier2Terrain, tTier3Terrain]], [1, 1]),
+			paintClass(clDirt)
+		],
 		[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12), stayClasses(clLand, 5)],
-		scaleByMapSize(15, 45)
-	);
-}
+		scaleByMapSize(15, 45));
 
 log("Creating grass patches...");
-var sizes = [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)];
-for (var i = 0; i < sizes.length; i++)
-{
-	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
-	painter = new TerrainPainter(tTier4Terrain);
+for (let size of [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)])
 	createAreas(
-		placer,
-		painter,
+		new ClumpPlacer(size, 0.3, 0.06, 0.5),
+		new TerrainPainter(tTier4Terrain),
 		[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12), stayClasses(clLand, 5)],
-		scaleByMapSize(15, 45)
-	);
-}
+		scaleByMapSize(15, 45));
 
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
@@ -1746,19 +1725,14 @@ createObjectGroupsDeprecated(group, 0,
 RMS.SetProgress(85);
 
 log("Creating straggler trees...");
-var types = [oTree1, oTree2, oTree4, oTree3];	// some variation
+var types = [oTree1, oTree2, oTree4, oTree3];
 var num = floor(numStragglers / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	group = new SimpleGroup(
-		[new SimpleObject(types[i], 1,1, 0,3)],
-		true, clForest
-	);
-	createObjectGroupsDeprecated(group, 0,
+for (let type of types)
+	createObjectGroupsDeprecated(
+		new SimpleGroup([new SimpleObject(type, 1, 1, 0, 3)], true, clForest),
+		0,
 		[avoidClasses(clForest, 1, clHill, 1, clPlayer, 9, clMetal, 6, clRock, 6), stayClasses(clLand, 4)],
-		num
-	);
-}
+		num);
 
 var planetm = 1;
 if (currentBiome() == "tropic")
diff --git a/binaries/data/mods/public/maps/random/survivalofthefittest.js b/binaries/data/mods/public/maps/random/survivalofthefittest.js
index c9e3142da6..46784e4f2d 100644
--- a/binaries/data/mods/public/maps/random/survivalofthefittest.js
+++ b/binaries/data/mods/public/maps/random/survivalofthefittest.js
@@ -68,6 +68,7 @@ createArea(
 		paintClass(clLand)
 	],
 	null);
+RMS.SetProgress(10);
 
 var [playerIDs, playerX, playerZ, playerAngle, startAngle] = radialPlayerPlacement(0.3);
 
@@ -146,6 +147,7 @@ for (let i = 0; i < numPlayers; ++i)
 		addToClass(floor(femaleLocation[0]), floor(femaleLocation[1]), clWomen);
 	}
 }
+RMS.SetProgress(20);
 
 paintTerrainBasedOnHeight(3.12, 29, 1, tCliff);
 paintTileClassBasedOnHeight(3.12, 29, 1, clHill);
@@ -157,6 +159,7 @@ for (let triggerPointTreasure of triggerPointTreasures)
 		[avoidClasses(clForest, 5, clPlayer, 5, clHill, 5), stayClasses(clLand, 5)],
 		scaleByMapSize(40, 140), 100
 	);
+RMS.SetProgress(25);
 
 createBumps(stayClasses(clLand, 5));
 
@@ -166,6 +169,7 @@ createForests(
 	clForest,
 	1,
 	...rBiomeTreeCount(1));
+RMS.SetProgress(30);
 
 if (randBool())
 	createHills(
@@ -179,6 +183,7 @@ else
 		[avoidClasses(clPlayer, 20, clHill, 5, clBaseResource, 3, clWomen, 5), stayClasses(clLand, 5)],
 		clHill,
 		scaleByMapSize(10, 60) * numPlayers);
+RMS.SetProgress(40);
 
 createHills(
 	[tCliff, tCliff, tHill],
diff --git a/binaries/data/mods/public/maps/random/syria.js b/binaries/data/mods/public/maps/random/syria.js
index 12b1444d3b..8eee2afa58 100644
--- a/binaries/data/mods/public/maps/random/syria.js
+++ b/binaries/data/mods/public/maps/random/syria.js
@@ -136,28 +136,22 @@ for (var i = 0; i < numPlayers; i++)
 RMS.SetProgress(10);
 
 log("Creating bumps...");
-placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1);
-painter = new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2);
 createAreas(
-	placer,
-	painter,
+	new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1),
+	new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2),
 	avoidClasses(clPlayer, 13),
-	scaleByMapSize(300, 800)
-);
+	scaleByMapSize(300, 800));
 
 log("Creating hills...");
-placer = new ChainPlacer(1, floor(scaleByMapSize(4, 6)), floor(scaleByMapSize(16, 40)), 0.5);
-var terrainPainter = new LayeredPainter(
-	[tCliff, tHill],		// terrains
-	[2]								// widths
-);
-var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 22, 2);
 createAreas(
-	placer,
-	[terrainPainter, elevationPainter, paintClass(clHill)],
+	new ChainPlacer(1, Math.floor(scaleByMapSize(4, 6)), Math.floor(scaleByMapSize(16, 40)), 0.5),
+	[
+		new LayeredPainter([tCliff, tHill], [2]),
+		new SmoothElevationPainter(ELEVATION_SET, 22, 2),
+		paintClass(clHill)
+	],
 	avoidClasses(clPlayer, 3, clGrass, 1, clHill, 10),
-	scaleByMapSize(1, 3) * numPlayers * 3
-);
+	scaleByMapSize(1, 3) * numPlayers * 3);
 
 RMS.SetProgress(25);
 
@@ -174,64 +168,45 @@ log("Creating forests...");
 var types = [
 	[[tMainDirt, tForestFloor2, pForestP], [tForestFloor2, pForestP]],
 	[[tMainDirt, tForestFloor1, pForestT], [tForestFloor1, pForestT]]
-];	// some variation
+];
 var size = numForest / (scaleByMapSize(3,6) * numPlayers);
 var num = floor(size / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), numForest / (num * floor(scaleByMapSize(2,4))), 0.5);
-	painter = new LayeredPainter(
-		types[i],		// terrains
-		[2]											// widths
-		);
+for (let type of types)
 	createAreas(
-		placer,
-		[painter, paintClass(clForest)],
+		new ChainPlacer(
+			1,
+			Math.floor(scaleByMapSize(3, 5)),
+			numForest / (num * Math.floor(scaleByMapSize(2, 4))),
+			0.5),
+		[
+			new LayeredPainter(type, [2]),
+			paintClass(clForest)
+		],
 		avoidClasses(clPlayer, 1, clGrass, 1, clForest, 10, clHill, 1),
-		num
-	);
-}
+		num);
 
 RMS.SetProgress(40);
 
 log("Creating dirt patches...");
-var sizes = [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)];
-for (var i = 0; i < sizes.length; i++)
-{
-	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
-	painter = new LayeredPainter(
-		[tSecondaryDirt ,tDirt], 		// terrains
-		[1]															// widths
-	);
+for (let size of [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)])
 	createAreas(
-		placer,
-		painter,
+		new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
+		new LayeredPainter([tSecondaryDirt, tDirt], [1]),
 		avoidClasses(clHill, 0, clForest, 0, clPlayer, 8, clGrass, 1),
-		scaleByMapSize(50, 90)
-	);
-}
+		scaleByMapSize(50, 90));
 RMS.SetProgress(60);
 
 log("Creating big patches...");
-var sizes = [scaleByMapSize(6, 30), scaleByMapSize(10, 50), scaleByMapSize(16, 70)];
-for (var i = 0; i < sizes.length; i++)
-{
-	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
-	painter = new LayeredPainter(
-		[tSecondaryDirt ,tDirt], 		// terrains
-		[1]															// widths
-	);
+for (let size of [scaleByMapSize(6, 30), scaleByMapSize(10, 50), scaleByMapSize(16, 70)])
 	createAreas(
-		placer,
-		painter,
+		new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
+		new LayeredPainter([tSecondaryDirt, tDirt], [1]),
 		avoidClasses(clHill, 0, clForest, 0, clPlayer, 8, clGrass, 1),
-		scaleByMapSize(30, 90)
-	);
-}
+		scaleByMapSize(30, 90));
 RMS.SetProgress(70);
 
 log("Creating stone mines...");
-group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4), new RandomObject(aBushes, 2,4, 0,2)], true, clRock);
+var group = new SimpleGroup([new SimpleObject(oStoneSmall, 0, 2, 0, 4), new SimpleObject(oStoneLarge, 1, 1, 0,4), new RandomObject(aBushes, 2, 4, 0, 2)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 10, clRock, 10, clHill, 1, clGrass, 1)],
 	scaleByMapSize(2,8), 100
@@ -306,34 +281,24 @@ createObjectGroupsDeprecated(group, 0,
 RMS.SetProgress(85);
 
 log("Creating straggler trees...");
-var types = [oPalm, oTamarix, oPine];	// some variation
+var types = [oPalm, oTamarix, oPine];
 var num = floor(numStragglers / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	group = new SimpleGroup(
-		[new SimpleObject(types[i], 1,1, 0,3)],
-		true, clForest
-	);
-	createObjectGroupsDeprecated(group, 0,
+for (let type of types)
+	createObjectGroupsDeprecated(
+		new SimpleGroup([new SimpleObject(type, 1, 1, 0, 3)], true, clForest),
+		0,
 		avoidClasses(clForest, 1, clHill, 1, clPlayer, 1, clMetal, 6, clRock, 6),
-		num
-	);
-}
+		num);
 
 log("Creating straggler trees...");
-var types = [oPalm, oTamarix, oPine];	// some variation
+var types = [oPalm, oTamarix, oPine];
 var num = floor(numStragglers / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	group = new SimpleGroup(
-		[new SimpleObject(types[i], 1,1, 0,3)],
-		true, clForest
-	);
-	createObjectGroupsDeprecated(group, 0,
+for (let type of types)
+	createObjectGroupsDeprecated(
+		new SimpleGroup([new SimpleObject(type, 1,1, 0,3)], true, clForest),
+		0,
 		[avoidClasses(clForest, 1, clHill, 1, clPlayer, 1, clMetal, 6, clRock, 6), stayClasses(clGrass, 3)],
-		num
-	);
-}
+		num);
 
 setSkySet("sunny");
 setSunElevation(PI / 8);
diff --git a/binaries/data/mods/public/maps/random/the_nile.js b/binaries/data/mods/public/maps/random/the_nile.js
index 49c2a63c37..218f7945b9 100644
--- a/binaries/data/mods/public/maps/random/the_nile.js
+++ b/binaries/data/mods/public/maps/random/the_nile.js
@@ -217,51 +217,42 @@ paintRiver({
 RMS.SetProgress(40);
 
 log("Creating bumps...");
-placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1);
-painter = new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2);
 createAreas(
-	placer,
-	painter,
+	new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1),
+	new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2),
 	avoidClasses(clWater, 2, clPlayer, 6),
-	scaleByMapSize(100, 200)
-);
+	scaleByMapSize(100, 200));
 
 log("Creating ponds...");
-var numLakes = round(scaleByMapSize(1,4) * numPlayers / 2);
-placer = new ClumpPlacer(scaleByMapSize(100,250), 0.8, 0.1, 10);
-var terrainPainter = new LayeredPainter(
-	[tShore, tShore, tShore],		// terrains
-	[1,1]							// widths
-);
-var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -7, 4);
+var numLakes = Math.round(scaleByMapSize(1, 4) * numPlayers / 2);
 var waterAreas = createAreas(
-	placer,
-	[terrainPainter, elevationPainter, paintClass(clPond)],
+	new ClumpPlacer(scaleByMapSize(2, 5) * 50, 0.8, 0.1, 10),
+	[
+		new LayeredPainter([tShore, tShore, tShore], [1, 1]),
+		new SmoothElevationPainter(ELEVATION_SET, -7, 4),
+		paintClass(clPond)
+	],
 	avoidClasses(clPlayer, 25, clWater, 20, clPond, 10),
 	numLakes
 );
 
 log("Creating reeds...");
-group = new SimpleGroup(
-	[new SimpleObject(aReeds, 1,3, 0,1)],
-	true
-);
-createObjectGroupsByAreasDeprecated(group, 0,
+createObjectGroupsByAreasDeprecated(
+	new SimpleGroup([new SimpleObject(aReeds, 1, 3, 0, 1)], true),
+	0,
 	stayClasses(clPond, 1),
-	numLakes, 100,
-	waterAreas
-);
+	numLakes,
+	100,
+	waterAreas);
 
 log("Creating lillies...");
-group = new SimpleGroup(
-	[new SimpleObject(aLillies, 1,3, 0,1)],
-	true
-);
-createObjectGroupsByAreasDeprecated(group, 0,
+createObjectGroupsByAreasDeprecated(
+	new SimpleGroup([new SimpleObject(aLillies, 1, 3, 0, 1)], true),
+	0,
 	stayClasses(clPond, 1),
-	numLakes, 100,
-	waterAreas
-);
+	numLakes,
+	100,
+	waterAreas);
 
 waterAreas = [];
 
@@ -276,54 +267,49 @@ var numStragglers = totalTrees * (1.0 - P_FOREST);
 
 log("Creating forests...");
 var num = scaleByMapSize(10,30);
-placer = new ClumpPlacer(numForest / num, 0.15, 0.1, 0.5);
-painter = new TerrainPainter([pForest, tForestFloor]);
-createAreas(placer, [painter, paintClass(clForest)],
+createAreas(
+	new ClumpPlacer(numForest / num, 0.15, 0.1, 0.5),
+	[
+		new TerrainPainter([pForest, tForestFloor]),
+		paintClass(clForest)
+	],
 	avoidClasses(clPlayer, 19, clForest, 4, clWater, 1, clDesert, 5, clPond, 2, clBaseResource, 3),
-	num, 50
-);
+	num,
+	50);
 
 RMS.SetProgress(50);
 
 log("Creating grass patches...");
-var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
-for (var i = 0; i < sizes.length; i++)
-{
-	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
-	painter = new LayeredPainter(
-		[[tGrass,tGrassSand50],[tGrassSand50,tGrassSand25], [tGrassSand25,tGrass]], 		// terrains
-		[1,1]															// widths
-	);
+for (let size of [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)])
 	createAreas(
-		placer,
-		[painter, paintClass(clDirt)],
+		new ClumpPlacer(size, 0.3, 0.06, 0.5),
+		[
+			new LayeredPainter(
+				[[tGrass, tGrassSand50], [tGrassSand50, tGrassSand25], [tGrassSand25, tGrass]],
+				[1, 1]),
+			paintClass(clDirt)
+		],
 		avoidClasses(clForest, 0, clGrass, 5, clPlayer, 10, clWater, 1, clDirt, 5, clShore, 1, clPond, 1),
-		scaleByMapSize(15, 45)
-	);
-}
+		scaleByMapSize(15, 45));
 RMS.SetProgress(55);
 
 log("Creating dirt patches...");
-var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
-for (var i = 0; i < sizes.length; i++)
-{
-	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
-	painter = new LayeredPainter(
-		[[tDirt,tDirtCracks],[tDirt,tFineSand], [tDirtCracks,tFineSand]], 		// terrains
-		[1,1]															// widths
-	);
+for (let size of [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)])
 	createAreas(
-		placer,
-		[painter, paintClass(clDirt)],
+		new ClumpPlacer(size, 0.3, 0.06, 0.5),
+		[
+			new LayeredPainter(
+				[[tDirt, tDirtCracks], [tDirt, tFineSand], [tDirtCracks, tFineSand]],
+				[1, 1]),
+			paintClass(clDirt)
+		],
 		avoidClasses(clForest, 0, clDirt, 5, clPlayer, 10, clWater, 1, clGrass, 5, clShore, 1, clPond, 1),
-		scaleByMapSize(15, 45)
-	);
-}
+		scaleByMapSize(15, 45));
 
 RMS.SetProgress(60);
 
 log("Creating stone mines...");
-group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
+var group = new SimpleGroup([new SimpleObject(oStoneSmall, 0, 2, 0, 4), new SimpleObject(oStoneLarge, 1, 1, 0, 4)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 1, clPlayer, 20, clRock, 10, clWater, 1, clPond, 1),
 	scaleByMapSize(4,16), 100
@@ -426,39 +412,33 @@ createObjectGroupsDeprecated(group, 0,
 RMS.SetProgress(90);
 
 log("Creating straggler trees...");
-var types = [oDatePalm, oSDatePalm];	// some variation
+var types = [oDatePalm, oSDatePalm];
 var num = floor(0.5 * numStragglers / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	group = new SimpleGroup([new SimpleObject(types[i], 1,1, 0,0)], true);
-	createObjectGroupsDeprecated(group, 0,
+for (let type of types)
+	createObjectGroupsDeprecated(
+		new SimpleGroup([new SimpleObject(type, 1, 1, 0, 0)], true),
+		0,
 		avoidClasses(clForest, 0, clWater, 1, clPlayer, 20, clMetal, 6, clDesert, 1, clTreasure, 2, clPond, 1),
-		num
-	);
-}
+		num);
 
-var types = [oDatePalm, oSDatePalm];	// some variation
+var types = [oDatePalm, oSDatePalm];
 var num = floor(0.1 * numStragglers / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	group = new SimpleGroup([new SimpleObject(types[i], 1,1, 0,0)], true);
-	createObjectGroupsDeprecated(group, 0,
+for (let type of types)
+	createObjectGroupsDeprecated(
+		new SimpleGroup([new SimpleObject(type, 1,1, 0,0)], true),
+		0,
 		avoidClasses(clForest, 0, clWater, 1, clPlayer, 20, clMetal, 6, clTreasure, 2),
-		num
-	);
-}
+		num);
 
 log("Creating straggler trees...");
-var types = [oDatePalm, oSDatePalm];	// some variation
+var types = [oDatePalm, oSDatePalm];
 var num = floor(numStragglers / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	group = new SimpleGroup([new SimpleObject(types[i], 1,1, 0,0)], true);
-	createObjectGroupsDeprecated(group, 0,
+for (let type of types)
+	createObjectGroupsDeprecated(
+		new SimpleGroup([new SimpleObject(type, 1, 1, 0, 0)], true),
+		0,
 		borderClasses(clPond, 1, 4),
-		num
-	);
-}
+		num);
 
 log("Creating obelisks");
 group = new SimpleGroup(
diff --git a/binaries/data/mods/public/maps/random/volcanic_lands.js b/binaries/data/mods/public/maps/random/volcanic_lands.js
index 73b7987924..d28148e09f 100644
--- a/binaries/data/mods/public/maps/random/volcanic_lands.js
+++ b/binaries/data/mods/public/maps/random/volcanic_lands.js
@@ -132,77 +132,55 @@ log("Creating forests...");
 var types = [
 	[[tGrassB, tGrassA, pForestD], [tGrassB, pForestD]],
 	[[tGrassB, tGrassA, pForestP], [tGrassB, pForestP]]
-];	// some variation
-
+];
 var size = numForest / (scaleByMapSize(2,8) * numPlayers);
-
 var num = floor(size / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	placer = new ClumpPlacer(numForest / num, 0.1, 0.1, 1);
-	painter = new LayeredPainter(
-		types[i],		// terrains
-		[2]											// widths
-		);
+for (let type of types)
 	createAreas(
-		placer,
-		[painter, paintClass(clForest)],
-		avoidClasses(clPlayer, 12, clForest, 10, clHill, 0),
-		num
-	);
-}
+		new ClumpPlacer(numForest / num, 0.1, 0.1, 1),
+		[
+			new LayeredPainter(type, [2]),
+			paintClass(clForest)
+		],
+		avoidClasses(clPlayer, 12, clForest, 10, clHill, 0, clBaseResource, 6),
+		num);
 
 RMS.SetProgress(70);
 
 log("Creating dirt patches...");
-var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
-for (var i = 0; i < sizes.length; i++)
-{
-	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
-	painter = new LayeredPainter(
-		[tGrassA,tGrassA], 		// terrains
-		[1]															// widths
-	);
+for (let size of [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)])
 	createAreas(
-		placer,
-		[painter, paintClass(clDirt)],
+		new ClumpPlacer(size, 0.3, 0.06, 0.5),
+		[
+			new LayeredPainter([tGrassA, tGrassA], [1]),
+			paintClass(clDirt)
+		],
+		avoidClasses(clForest, 0, clHill, 0, clPlayer, 12),
+		scaleByMapSize(20, 80));
+
+for (let size of [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)])
+	createAreas(
+		new ClumpPlacer(size, 0.3, 0.06, 0.5),
+		[
+			new LayeredPainter([tGrassB, tGrassB], [1]),
+			paintClass(clDirt)
+		],
+		avoidClasses(clForest, 0, clHill, 0, clPlayer, 12),
+		scaleByMapSize(20, 80));
+
+for (let size of [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)])
+	createAreas(
+		new ClumpPlacer(size, 0.3, 0.06, 0.5),
+		[
+			new LayeredPainter([tGrassC, tGrassC], [1]),
+			paintClass(clDirt)
+		],
 		avoidClasses(clForest, 0, clHill, 0, clPlayer, 12),
 		scaleByMapSize(20, 80)
 	);
-}
-var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
-for (var i = 0; i < sizes.length; i++)
-{
-	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
-	painter = new LayeredPainter(
-		[tGrassB,tGrassB], 		// terrains
-		[1]															// widths
-	);
-	createAreas(
-		placer,
-		[painter, paintClass(clDirt)],
-		avoidClasses(clForest, 0, clHill, 0, clPlayer, 12),
-		scaleByMapSize(20, 80)
-	);
-}
-var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
-for (var i = 0; i < sizes.length; i++)
-{
-	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
-	painter = new LayeredPainter(
-		[tGrassC,tGrassC], 		// terrains
-		[1]															// widths
-	);
-	createAreas(
-		placer,
-		[painter, paintClass(clDirt)],
-		avoidClasses(clForest, 0, clHill, 0, clPlayer, 12),
-		scaleByMapSize(20, 80)
-	);
-}
 
 log("Creating stone mines...");
-group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
+var group = new SimpleGroup([new SimpleObject(oStoneSmall, 0, 2, 0, 4), new SimpleObject(oStoneLarge, 1, 1, 0, 4)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 1, clPlayer, 10, clRock, 10, clHill, 1),
 	scaleByMapSize(4,16), 100
@@ -249,18 +227,13 @@ createObjectGroupsDeprecated(
 RMS.SetProgress(95);
 
 log("Creating straggler trees...");
-var types = [oTree];	// some variation
+var types = [oTree];
 var num = floor(numStragglers / types.length);
-for (var i = 0; i < types.length; ++i)
-{
-	group = new SimpleGroup(
-		[new SimpleObject(types[i], 1,1, 0,3)],
-		true, clForest
-	);
-	createObjectGroupsDeprecated(group, 0,
-		avoidClasses(clForest, 1, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6),
-		num
-	);
-}
+for (let type of types)
+	createObjectGroupsDeprecated(
+		new SimpleGroup([new SimpleObject(type, 1, 1, 0, 3)], true, clForest),
+		0,
+		avoidClasses(clForest, 1, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6, clBaseResource, 6),
+		num);
 
 ExportMap();