Index: ps/trunk/binaries/data/mods/public/maps/random/lake.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/lake.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/lake.js	(revision 20301)
@@ -1,308 +1,303 @@
 RMS.LoadLibrary("rmgen");
 RMS.LoadLibrary("rmbiome");
 
 setSelectedBiome();
 
 const tMainTerrain = g_Terrains.mainTerrain;
 const tForestFloor1 = g_Terrains.forestFloor1;
 const tForestFloor2 = g_Terrains.forestFloor2;
 const tCliff = g_Terrains.cliff;
 const tTier1Terrain = g_Terrains.tier1Terrain;
 const tTier2Terrain = g_Terrains.tier2Terrain;
 const tTier3Terrain = g_Terrains.tier3Terrain;
 const tHill = g_Terrains.hill;
 const tRoad = g_Terrains.road;
 const tRoadWild = g_Terrains.roadWild;
 const tTier4Terrain = g_Terrains.tier4Terrain;
 const tShore = g_Terrains.shore;
 const tWater = g_Terrains.water;
 
 const oTree1 = g_Gaia.tree1;
 const oTree2 = g_Gaia.tree2;
 const oTree3 = g_Gaia.tree3;
 const oTree4 = g_Gaia.tree4;
 const oTree5 = g_Gaia.tree5;
 const oFruitBush = g_Gaia.fruitBush;
 const oMainHuntableAnimal = g_Gaia.mainHuntableAnimal;
 const oFish = g_Gaia.fish;
 const oSecondaryHuntableAnimal = g_Gaia.secondaryHuntableAnimal;
 const oStoneLarge = g_Gaia.stoneLarge;
 const oStoneSmall = g_Gaia.stoneSmall;
 const oMetalLarge = g_Gaia.metalLarge;
 
 const aGrass = g_Decoratives.grass;
 const aGrassShort = g_Decoratives.grassShort;
 const aRockLarge = g_Decoratives.rockLarge;
 const aRockMedium = g_Decoratives.rockMedium;
 const aBushMedium = g_Decoratives.bushMedium;
 const aBushSmall = g_Decoratives.bushSmall;
 
 const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
 const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 
 initTerrain(tMainTerrain);
 
 var [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 	addCivicCenterAreaToClass(ix, iz, clPlayer);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oFruitBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 		mAngle = randFloat(0, TWO_PI);
 
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var num = 5;
 	var tAngle = randFloat(0, TWO_PI);
 	var tDist = randFloat(12, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oTree1, num, num, 0,3)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 
 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);
 paintTerrainBasedOnHeight(-8, 1, 2, tWater);
 paintTileClassBasedOnHeight(-6, 0, 1, clWater);
 
 for (var i = 0; i < numPlayers; ++i)
 {
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	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);
 }
 
 createBumps(avoidClasses(clWater, 2, clPlayer, 20));
 
 if (randBool())
 	createHills([tMainTerrain, tCliff, tHill], avoidClasses(clPlayer, 20, clHill, 15, clWater, 2), clHill, scaleByMapSize(1, 4) * numPlayers);
 else
 	createMountains(tCliff, avoidClasses(clPlayer, 20, clHill, 15, clWater, 2), clHill, scaleByMapSize(1, 4) * numPlayers);
 
 createForests(
  [tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
  avoidClasses(clPlayer, 20, clForest, 17, clHill, 0, clWater, 2),
  clForest,
  1,
  ...rBiomeTreeCount(1));
 
 RMS.SetProgress(50);
 
 log("Creating dirt patches...");
 createLayeredPatches(
  [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
  [[tMainTerrain,tTier1Terrain],[tTier1Terrain,tTier2Terrain], [tTier2Terrain,tTier3Terrain]],
  [1,1],
  avoidClasses(clWater, 3, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12)
 );
 
 log("Creating grass patches...");
 createPatches(
  [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
  tTier4Terrain,
  avoidClasses(clWater, 3, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12)
 );
 
 RMS.SetProgress(55);
 
 log("Creating stone mines...");
 createMines(
  [
   [new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)],
   [new SimpleObject(oStoneSmall, 2,5, 1,3)]
  ],
  avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clRock, 10, clHill, 1)
 );
 
 log("Creating metal mines...");
 createMines(
  [
   [new SimpleObject(oMetalLarge, 1,1, 0,4)]
  ],
  avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 1),
  clMetal
 );
 
 RMS.SetProgress(65);
 
 var planetm = 1;
 
 if (currentBiome() == "tropic")
 	planetm = 8;
 
 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),
   planetm * scaleByMapSize(13, 200),
   planetm * scaleByMapSize(13, 200),
   planetm * scaleByMapSize(13, 200)
  ],
  avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0)
 );
 
 RMS.SetProgress(70);
 
 createFood
 (
  [
   [new SimpleObject(oMainHuntableAnimal, 5,7, 0,4)],
   [new SimpleObject(oSecondaryHuntableAnimal, 2,3, 0,2)]
  ],
  [
   3 * numPlayers,
   3 * numPlayers
  ],
  avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 20)
 );
 
 createFood
 (
  [
   [new SimpleObject(oFruitBush, 5,7, 0,4)]
  ],
  [
   3 * numPlayers
  ],
  avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 10)
 );
 
 createFood
 (
  [
   [new SimpleObject(oFish, 2,3, 0,2)]
  ],
  [
   25 * numPlayers
  ],
  [avoidClasses(clFood, 20), stayClasses(clWater, 6)]
 );
 
 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");
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/mainland.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/mainland.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/mainland.js	(revision 20301)
@@ -1,239 +1,238 @@
 RMS.LoadLibrary("rmgen");
 RMS.LoadLibrary("rmbiome");
 
 setSelectedBiome();
 
 const tMainTerrain = g_Terrains.mainTerrain;
 const tForestFloor1 = g_Terrains.forestFloor1;
 const tForestFloor2 = g_Terrains.forestFloor2;
 const tCliff = g_Terrains.cliff;
 const tTier1Terrain = g_Terrains.tier1Terrain;
 const tTier2Terrain = g_Terrains.tier2Terrain;
 const tTier3Terrain = g_Terrains.tier3Terrain;
 const tHill = g_Terrains.hill;
 const tRoad = g_Terrains.road;
 const tRoadWild = g_Terrains.roadWild;
 const tTier4Terrain = g_Terrains.tier4Terrain;
 
 const oTree1 = g_Gaia.tree1;
 const oTree2 = g_Gaia.tree2;
 const oTree3 = g_Gaia.tree3;
 const oTree4 = g_Gaia.tree4;
 const oTree5 = g_Gaia.tree5;
 const oFruitBush = g_Gaia.fruitBush;
 const oMainHuntableAnimal = g_Gaia.mainHuntableAnimal;
 const oSecondaryHuntableAnimal = g_Gaia.secondaryHuntableAnimal;
 const oStoneLarge = g_Gaia.stoneLarge;
 const oStoneSmall = g_Gaia.stoneSmall;
 const oMetalLarge = g_Gaia.metalLarge;
 
 const aGrass = g_Decoratives.grass;
 const aGrassShort = g_Decoratives.grassShort;
 const aRockLarge = g_Decoratives.rockLarge;
 const aRockMedium = g_Decoratives.rockMedium;
 const aBushMedium = g_Decoratives.bushMedium;
 const aBushSmall = g_Decoratives.bushSmall;
 
 const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
 const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 
 initTerrain(tMainTerrain);
 
 var [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 	addCivicCenterAreaToClass(ix, iz, clPlayer);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	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);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oFruitBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var num = 5;
 	var tAngle = randFloat(0, TWO_PI);
 	var tDist = randFloat(12, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oTree1, num, num, 0,3)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 RMS.SetProgress(20);
 
 createBumps();
 
 if (randBool())
 	createHills([tCliff, tCliff, tHill], avoidClasses(clPlayer, 20, clHill, 15), clHill, scaleByMapSize(3, 15));
 else
 	createMountains(tCliff, avoidClasses(clPlayer, 20, clHill, 15), clHill, scaleByMapSize(3, 15));
 
 createForests(
  [tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
  avoidClasses(clPlayer, 20, clForest, 18, clHill, 0),
  clForest,
  1,
  ...rBiomeTreeCount(1));
 
 RMS.SetProgress(50);
 
 log("Creating dirt patches...");
 createLayeredPatches(
  [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
  [[tMainTerrain,tTier1Terrain],[tTier1Terrain,tTier2Terrain], [tTier2Terrain,tTier3Terrain]],
  [1,1]
 );
 
 log("Creating grass patches...");
 createPatches(
  [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
  tTier4Terrain
 );
 
 RMS.SetProgress(55);
 
 log("Creating stone mines...");
 createMines(
  [
   [new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)],
   [new SimpleObject(oStoneSmall, 2,5, 1,3)]
  ]
 );
 
 log("Creating metal mines...");
 createMines(
  [
   [new SimpleObject(oMetalLarge, 1,1, 0,4)]
  ],
  avoidClasses(clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 1),
  clMetal
 );
 
 RMS.SetProgress(65);
 
 var planetm = 1;
 
 if (currentBiome() == "tropic")
 	planetm = 8;
 
 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),
   planetm * scaleByMapSize(13, 200),
   planetm * scaleByMapSize(13, 200),
   planetm * scaleByMapSize(13, 200)
  ]
 );
 
 RMS.SetProgress(70);
 
 createFood
 (
  [
   [new SimpleObject(oMainHuntableAnimal, 5,7, 0,4)],
   [new SimpleObject(oSecondaryHuntableAnimal, 2,3, 0,2)]
  ],
  [
   3 * numPlayers,
   3 * numPlayers
  ]
 );
 
 RMS.SetProgress(75);
 
 createFood
 (
  [
   [new SimpleObject(oFruitBush, 5,7, 0,4)]
  ],
  [
   3 * numPlayers
  ],
  avoidClasses(clForest, 0, clPlayer, 20, clHill, 1, clFood, 10)
 );
 
 RMS.SetProgress(85);
 
-var types = [oTree1, oTree2, oTree4, oTree3];	// some variation
-createStragglerTrees(types);
+createStragglerTrees([oTree1, oTree2, oTree4, oTree3]);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/aegean_sea.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/aegean_sea.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/aegean_sea.js	(revision 20301)
@@ -1,354 +1,354 @@
 RMS.LoadLibrary("rmgen");
 
 TILE_CENTERED_HEIGHT_MAP = true;
 
 const tCity = "medit_city_pavement";
 const tCityPlaza = "medit_city_pavement";
 const tHill = ["medit_grass_shrubs", "medit_rocks_grass_shrubs", "medit_rocks_shrubs", "medit_rocks_grass", "medit_shrubs"];
 const tMainDirt = "medit_dirt";
 const tCliff = "medit_cliff_aegean";
 const tForestFloor = "medit_grass_shrubs";
 const tGrass = "medit_grass_field";
 const tGrassSand50 = "medit_grass_field_a";
 const tGrassSand25 = "medit_grass_field_b";
 const tDirt = "medit_dirt_b";
 const tDirt2 = "medit_rocks_grass";
 const tDirt3 = "medit_rocks_shrubs";
 const tDirtCracks = "medit_dirt_c";
 const tShore = "medit_sand";
 const tWater = "medit_sand_wet";
 const tCorals1 = "medit_sea_coral_plants";
 const tCorals2 = "medit_sea_coral_deep";
 const tSeaDepths = "medit_sea_depths";
 
 const oBerryBush = "gaia/flora_bush_berry";
 const oDeer = "gaia/fauna_deer";
 const oFish = "gaia/fauna_fish";
 const oSheep = "gaia/fauna_sheep";
 const oGoat = "gaia/fauna_goat";
 const oStoneLarge = "gaia/geology_stonemine_medit_quarry";
 const oStoneSmall = "gaia/geology_stone_mediterranean";
 const oMetalLarge = "gaia/geology_metal_mediterranean_slabs";
 const oDatePalm = "gaia/flora_tree_cretan_date_palm_short";
 const oSDatePalm = "gaia/flora_tree_cretan_date_palm_tall";
 const oCarob = "gaia/flora_tree_carob";
 const oFanPalm = "gaia/flora_tree_medit_fan_palm";
 const oPoplar = "gaia/flora_tree_poplar_lombardy";
 const oCypress = "gaia/flora_tree_cypress";
 
 const aBush1 = "actor|props/flora/bush_medit_sm.xml";
 const aBush2 = "actor|props/flora/bush_medit_me.xml";
 const aBush3 = "actor|props/flora/bush_medit_la.xml";
 const aBush4 = "actor|props/flora/bush_medit_me.xml";
 const aDecorativeRock = "actor|geology/stone_granite_med.xml";
 
 const pForest = [tForestFloor, tForestFloor + TERRAIN_SEPARATOR + oCarob, tForestFloor + TERRAIN_SEPARATOR + oDatePalm, tForestFloor + TERRAIN_SEPARATOR + oSDatePalm, tForestFloor];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 
 var clPlayer = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clGrass = createTileClass();
 var clHill = createTileClass();
 var clIsland = createTileClass();
 var clCorals = createTileClass();
 
 var playerIDs = primeSortAllPlayers();
 var playerPos = placePlayersRiver();
 
 var playerX = [];
 var playerZ = [];
 
 for (var i = 0; i < numPlayers; i++)
 {
 	playerZ[i] = playerPos[i];
 	playerX[i] = 0.2 + 0.6*(i%2);
 }
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = floor(fx);
 	var iz = floor(fz);
 	addToClass(ix, iz, clPlayer);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	var placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tCityPlaza, tCity], [1]);
 	createArea(placer, painter, null);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oBerryBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var num = 2;
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(11, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oCarob, num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aBush1, clBaseResource, radius);
 }
 RMS.SetProgress(30);
 
 paintRiver({
 	"horizontal": false,
 	"parallel": false,
 	"position": 0.5,
 	"width": 0.35,
 	"fadeDist": 0.025,
 	"deviation": 0,
 	"waterHeight": -3,
 	"landHeight": 2,
 	"meanderShort": 20,
 	"meanderLong": 0,
 	"waterFunc": (ix, iz, height) => {
 
 		if (height < 0.7)
 			addToClass(ix, iz, clWater);
 	}
 });
 
 paintTerrainBasedOnHeight(-20, 1, 0, tWater);
 paintTerrainBasedOnHeight(1, 2, 0, tShore);
 
 RMS.SetProgress(40);
 createBumps(avoidClasses(clWater, 2, clPlayer, 20));
 
 createForests(
  [tForestFloor, tForestFloor, tForestFloor, pForest, pForest],
  avoidClasses(clPlayer, 20, clForest, 17, clWater, 2, clBaseResource, 3),
  clForest
 );
 
 RMS.SetProgress(50);
 
 if (randBool())
 	createHills([tGrass, tCliff, tHill], avoidClasses(clPlayer, 20, clForest, 1, clHill, 15, clWater, 3), clHill, scaleByMapSize(3, 15));
 else
 	createMountains(tCliff, avoidClasses(clPlayer, 20, clForest, 1, clHill, 15, clWater, 3), clHill, scaleByMapSize(3, 15));
 
 log("Creating grass patches...");
 createLayeredPatches(
  [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
  [[tGrass,tGrassSand50],[tGrassSand50,tGrassSand25], [tGrassSand25,tGrass]],
  [1,1],
  avoidClasses(clForest, 0, clGrass, 2, clPlayer, 10, clWater, 2, clDirt, 2, clHill, 1)
 );
 
 RMS.SetProgress(55);
 
 log("Creating dirt patches...");
 createLayeredPatches(
  [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
  [tDirt3, tDirt2,[tDirt,tMainDirt], [tDirtCracks,tMainDirt]],
  [1,1,1],
  avoidClasses(clForest, 0, clDirt, 2, clPlayer, 10, clWater, 2, clGrass, 2, clHill, 1)
 );
 
 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
 );
 
 paintTerrainBasedOnHeight(-20, -3, 3, tSeaDepths);
 paintTerrainBasedOnHeight(-3, -2, 2, tCorals2);
 paintTerrainBasedOnHeight(-2, -1.5, 2, tCorals1);
 
 log("Creating island stone mines...");
 createMines(
  [
   [new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)],
   [new SimpleObject(oStoneSmall, 2,5, 1,3)]
  ],
  stayClasses(clIsland, 4)
 );
 
 log("Creating island metal mines...");
 createMines(
  [
   [new SimpleObject(oMetalLarge, 1,1, 0,4)]
  ],
  stayClasses(clIsland, 4),
  clMetal
 );
 
 log("Creating stone mines...");
 createMines(
  [
   [new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)],
   [new SimpleObject(oStoneSmall, 2,5, 1,3)]
  ],
  avoidClasses(clForest, 1, clPlayer, 20, clRock, 10, clWater, 1, clHill, 1)
 );
 
 log("Creating metal mines...");
 createMines(
  [
   [new SimpleObject(oMetalLarge, 1,1, 0,4)]
  ],
  avoidClasses(clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clWater, 1, clHill, 1),
  clMetal
 );
 
 RMS.SetProgress(65);
 
 createDecoration
 (
  [[new SimpleObject(aDecorativeRock, 1,3, 0,1)],
   [new SimpleObject(aBush2, 1,2, 0,1), new SimpleObject(aBush1, 1,3, 0,2), new SimpleObject(aBush4, 1,2, 0,1), new SimpleObject(aBush3, 1,3, 0,2)]
  ],
  [
   scaleByMapSize(16, 262),
   scaleByMapSize(40, 360)
  ],
  avoidClasses(clWater, 2, clForest, 0, clPlayer, 0, clHill, 1)
 );
 
 RMS.SetProgress(70);
 
 createFood
 (
  [
   [new SimpleObject(oFish, 2,3, 0,2)]
  ],
  [
   3*scaleByMapSize(5,20)
  ],
  [avoidClasses(clIsland, 2, clFood, 10), stayClasses(clWater, 5)]
 );
 
 createFood
 (
  [
   [new SimpleObject(oSheep, 5,7, 0,4)],
   [new SimpleObject(oGoat, 2,4, 0,3)],
   [new SimpleObject(oDeer, 2,4, 0,2)]
  ],
  [
   scaleByMapSize(5,20),
   scaleByMapSize(5,20),
   scaleByMapSize(5,20)
  ],
  avoidClasses(clForest, 0, clPlayer, 8, clWater, 1, clFood, 10, clHill, 1)
 );
 
 createFood
 (
  [
   [new SimpleObject(oBerryBush, 5,7, 0,4)]
  ],
  [
   3 * numPlayers
  ],
  avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 10)
 );
 
 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;
 createStragglerTrees(types, stayClasses(clIsland, 4));
 
 setSkySet("cumulus");
 setSunColor(0.866667, 0.776471, 0.486275);
 setWaterColor(0, 0.501961, 1);
 setWaterTint(0.501961, 1, 1);
 setWaterWaviness(4.0);
 setWaterType("ocean");
 setWaterMurkiness(0.49);
 
 setFogFactor(0.3);
 setFogThickness(0.25);
 
 setPPEffect("hdr");
 setPPContrast(0.62);
 setPPSaturation(0.51);
 setPPBloom(0.12);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/african_plains.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/african_plains.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/african_plains.js	(revision 20301)
@@ -1,326 +1,324 @@
 RMS.LoadLibrary("rmgen");
 
 var tPrimary = ["savanna_grass_a"];
 var tForestFloor = "savanna_forestfloor_a";
 var tCliff = ["savanna_cliff_a", "savanna_cliff_a_red", "savanna_cliff_b", "savanna_cliff_b_red"];
 var tSecondary = "savanna_grass_b";
 var tGrassShrubs = ["savanna_shrubs_a"];
 var tGrass = ["savanna_grass_a_wetseason", "savanna_grass_b_wetseason"];
 var tDirt = "savanna_dirt_a";
 var tDirt2 = "savanna_dirt_a_red";
 var tDirt3 = "savanna_dirt_b";
 var tDirt4 = "savanna_dirt_rocks_a";
 var tCitytiles = "savanna_tile_a";
 var tShore = "savanna_riparian_bank";
 var tWater = "savanna_riparian_wet";
 
 var oBaobab = "gaia/flora_tree_baobab";
 var oPalm = "gaia/flora_tree_senegal_date_palm";
 var oBerryBush = "gaia/flora_bush_berry";
 var oWildebeest = "gaia/fauna_wildebeest";
 var oZebra = "gaia/fauna_zebra";
 var oRhino = "gaia/fauna_rhino";
 var oLion = "gaia/fauna_lion";
 var oLioness = "gaia/fauna_lioness";
 var oHawk = "gaia/fauna_hawk";
 var oGiraffe = "gaia/fauna_giraffe";
 var oGiraffe2 = "gaia/fauna_giraffe_infant";
 var oGazelle = "gaia/fauna_gazelle";
 var oElephant = "gaia/fauna_elephant_african_bush";
 var oElephant2 = "gaia/fauna_elephant_african_infant";
 var oCrocodile = "gaia/fauna_crocodile";
 var oFish = "gaia/fauna_fish";
 var oStoneSmall = "gaia/geology_stone_savanna_small";
 var oMetalLarge = "gaia/geology_metal_savanna_slabs";
 
 var aBush = "actor|props/flora/bush_medit_sm_dry.xml";
 var aRock = "actor|geology/stone_savanna_med.xml";
 
 const pForest = [tForestFloor + TERRAIN_SEPARATOR + oPalm, tForestFloor];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 RMS.SetProgress(20);
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 
 initTerrain(tPrimary);
 
 var [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; ++i)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 	addCivicCenterAreaToClass(ix, iz, clPlayer);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	var placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tPrimary,tCitytiles], [1]);
 	createArea(placer, painter, null);
 
 	placeCivDefaultEntities(fx, fz, id);
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oBerryBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while (abs(mAngle - bbAngle) < PI/3)
 		mAngle = randFloat(0, TWO_PI);
 
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	createStoneMineFormation(mX, mZ, tDirt4);
 	addToClass(mX, mZ, clPlayer);
 
 	// create starting trees
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(11, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oBaobab, 2,7)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 }
 RMS.SetProgress(20);
 
 createHills([tDirt2, tCliff, tGrassShrubs], avoidClasses(clPlayer, 35, clForest, 20, clHill, 20, clWater, 2), clHill, scaleByMapSize(5, 8));
 RMS.SetProgress(30);
 
 var lakeAreas = [];
 var playerConstraint = new AvoidTileClassConstraint(clPlayer, 20);
 var waterConstraint = new AvoidTileClassConstraint(clWater, 8);
 
 for (var x = 0; x < mapSize; ++x)
 	for (var z = 0; z < mapSize; ++z)
 		if (playerConstraint.allows(x, z) && waterConstraint.allows(x, z))
 			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)
 );
 RMS.SetProgress(45);
 
 paintTerrainBasedOnHeight(3, floor(scaleByMapSize(20, 40)), 0, tCliff);
 paintTerrainBasedOnHeight(floor(scaleByMapSize(20, 40)), 100, 3, tGrass);
 
 createBumps(avoidClasses(clWater, 2, clPlayer, 20));
 
 createForests(
 	[tPrimary, tForestFloor, tForestFloor, pForest, pForest],
 	avoidClasses(clPlayer, 20, clForest, 20, clHill, 0, clWater, 2),
 	clForest,
 	1.0
 );
 
 log("Creating dirt patches...");
 createLayeredPatches(
 	[scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
 	[[tDirt,tDirt3], [tDirt2,tDirt4]],
 	[2],
 	avoidClasses(clWater, 3, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12)
 );
 
 log("Creating shrubs...");
 createPatches(
 	[scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
 	tGrassShrubs,
 	avoidClasses(clWater, 3, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12)
 );
 
 log("Creating grass patches...");
 createPatches(
 	[scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
 	tSecondary,
 	avoidClasses(clWater, 3, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12)
 );
 RMS.SetProgress(60);
 
 log("Creating stone mines...");
 createMines(
 	[
 		[new SimpleObject(oStoneSmall, 0,2, 0,4)],
 		[new SimpleObject(oStoneSmall, 2,5, 1,3)]
 	],
 	avoidClasses(clWater, 4, clForest, 4, clPlayer, 20, clRock, 10, clHill, 4)
 );
 
 log("Creating metal mines...");
 createMines(
 	[
 		[new SimpleObject(oMetalLarge, 1,1, 0,4)]
 	],
 	avoidClasses(clWater, 4, clForest, 4, clPlayer, 20, clMetal, 18, clRock, 5, clHill, 4),
 	clMetal
 );
 RMS.SetProgress(70);
 
 createDecoration(
 	[
 		[new SimpleObject(aBush, 1,3, 0,1)],
 		[new SimpleObject(aRock, 1,2, 0,1)]
 	],
 	[
 		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
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clPlayer, 20, clFood, 11, clHill, 4),
 	scaleByMapSize(4,12), 50
 );
 
 log("Creating elephants...");
 group = new SimpleGroup(
 	[new SimpleObject(oElephant, 2,4, 0,4), new SimpleObject(oElephant2, 0,2, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clPlayer, 20, clFood, 11, clHill, 4),
 	scaleByMapSize(4,12), 50
 );
 
 log("Creating lions...");
 group = new SimpleGroup(
 	[new SimpleObject(oLion, 0,1, 0,4), new SimpleObject(oLioness, 2,3, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clPlayer, 20, clFood, 11, clHill, 4),
 	scaleByMapSize(4,12), 50
 );
 
 createFood(
 	[
 		[new SimpleObject(oHawk, 1,1, 0,3)],
 		[new SimpleObject(oGazelle, 3,5, 0,3)],
 		[new SimpleObject(oZebra, 3,5, 0,3)],
 		[new SimpleObject(oWildebeest, 4,6, 0,3)],
 		[new SimpleObject(oRhino, 1,1, 0,3)]
 	],
 	[
 		3 * numPlayers,
 		3 * numPlayers,
 		3 * numPlayers,
 		3 * numPlayers,
 		3 * numPlayers,
 	],
 	avoidClasses(clFood, 20, clWater, 5, clHill, 2, clPlayer, 16)
 );
 
 createFood(
 	[
 		[new SimpleObject(oCrocodile, 2,3, 0,3)]
 	],
 	[
 		3 * numPlayers,
 	],
 	stayClasses(clWater, 6)
 );
 
 createFood(
 	[
 		[new SimpleObject(oBerryBush, 5,7, 0,4)]
 	],
 	[
 		randIntInclusive(1, 4) * numPlayers + 2
 	],
 	avoidClasses(clWater, 3, clForest, 2, clPlayer, 20, clHill, 3, clFood, 10)
 );
 
 createFood(
 	[
 		[new SimpleObject(oFish, 2,3, 0,2)]
 	],
 	[
 		15 * numPlayers
 	],
 	[avoidClasses(clFood, 20), stayClasses(clWater, 6)]
 );
 RMS.SetProgress(85);
 
 createStragglerTrees(
 	[oBaobab],
 	avoidClasses(clWater, 5, clForest, 2, clHill, 3, clPlayer, 12, clMetal, 4, clRock, 4)
 );
 
 setPPEffect("hdr");
 setPPSaturation(0.48);
 setPPContrast(0.53);
 setPPBloom(0.12);
 
 setFogThickness(0.25);
 setFogFactor(0.25);
 setFogColor(0.8, 0.7, 0.5);
 
 setSkySet("sunny");
 setSunRotation(randFloat(0, TWO_PI));
 setSunElevation(randFloat(PI/ 4, PI / 2));
 
 setWaterColor(0.223, 0.247, 0.2); // dark majestic blue
 setWaterTint(0.462, 0.756, 0.566); // light blue
 setWaterMurkiness(5.92);
 setWaterWaviness(0);
 setWaterType("clap");
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/polar_sea.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/polar_sea.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/polar_sea.js	(revision 20301)
@@ -1,333 +1,320 @@
 RMS.LoadLibrary("rmgen");
 
 var tPrimary = ["polar_snow_a"];
 var tCliff = ["polar_cliff_a", "polar_cliff_b", "polar_cliff_snow"];
 var tSecondary = "polar_snow_glacial";
 var tHalfSnow = ["ice_01", "ice_dirt"];
 var tSnowLimited = ["polar_snow_b", "polar_ice"];
 var tDirt = "ice_dirt";
 var tRoad = "polar_ice_b";
 var tRoadWild = "polar_ice_cracked";
 var tShore = "polar_ice_snow";
 var tWater = "polar_ice_c";
 
 var oArcticFox = "gaia/fauna_fox_arctic";
 var oWolf = "trigger/fauna_wolf_snow_attack";
 var oMuskox = "gaia/fauna_muskox";
 var oWalrus = "gaia/fauna_walrus";
 var oWhaleFin = "gaia/fauna_whale_fin";
 var oWhaleHumpback = "gaia/fauna_whale_humpback";
 var oFish = "gaia/fauna_fish";
 var oStoneLarge = "gaia/geology_stonemine_medit_quarry";
 var oStoneSmall = "gaia/geology_stone_alpine_a";
 var oMetalLarge = "gaia/geology_metal_desert_badlands_slabs";
 var oWood = "gaia/special_treasure_wood";
 
 var aRockLarge = "actor|geology/stone_granite_med.xml";
 var aRockMedium = "actor|geology/stone_granite_med.xml";
 var aIceberg = "actor|props/special/eyecandy/iceberg.xml";
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 
 var clPlayer = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clHill = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clWolf = createTileClass();
 
 // Expected by rmgen1
 var clForest = createTileClass();
 
 initTerrain(tPrimary);
 
 var [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 RMS.SetProgress(20);
 
 for (let i = 0; i < numPlayers; ++i)
 {
 	let id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	let fx = fractionToTiles(playerX[i]);
 	let fz = fractionToTiles(playerZ[i]);
 	let ix = Math.round(fx);
 	let iz = Math.round(fz);
 
 	addCivicCenterAreaToClass(ix, iz, clPlayer);
 
 	// Create the city patch
 	let cityRadius = scaleByMapSize(15,25)/3;
 	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);
 
 	placeCivDefaultEntities(fx, fz, id, { 'iberWall': 'towers' });
 
 	placeDefaultChicken(fx, fz, clBaseResource, undefined, oMuskox);
 
 	// Create metal mine
 	let mAngle = randFloat(0, TWO_PI);
 	let mDist = 12;
 	let mX = Math.round(fx + mDist * Math.cos(mAngle));
 	let mZ = Math.round(fz + mDist * Math.sin(mAngle));
 	let group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1, 1, 0, 0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// Create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = Math.round(fx + mDist * Math.cos(mAngle));
 	mZ = Math.round(fz + mDist * Math.sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1, 1, 0, 2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// Create wood treasure
 	mAngle += PI/4;
 	let bbX = Math.round(fx + mDist * Math.cos(mAngle));
 	let bbZ = Math.round(fz + mDist * Math.sin(mAngle));
 	createObjectGroup(
 		new SimpleGroup(
 			[new SimpleObject(oWood, 14,14, 0,3)],
 			true, clBaseResource, bbX, bbZ,
 			avoidClasses(clBaseResource, 4)
 		), 0);
 
 	// Create market
 	mAngle += PI/4;
 	placeObject(
 		Math.round(fx + mDist * Math.cos(mAngle)),
 		Math.round(fz + mDist * Math.sin(mAngle)),
 		"structures/" + getCivCode(id-1) + "_market",
 		id,
 		BUILDING_ORIENTATION);
 }
 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);
 RMS.SetProgress(40);
 
 log("Creating small lakes...");
 var lakeAreas = [];
 var playerConstraint = new AvoidTileClassConstraint(clPlayer, 20);
 var waterConstraint = new AvoidTileClassConstraint(clWater, 8);
 for (let x = 0; x < mapSize; ++x)
 	for (let z = 0; z < mapSize; ++z)
 		if (playerConstraint.allows(x, z) && waterConstraint.allows(x, z))
 			lakeAreas.push([x, z]);
 
 var numLakes = scaleByMapSize(10, 16);
 for (let i = 0; i < numLakes ; ++i)
 {
 	let chosenPoint = pickRandom(lakeAreas);
 	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);
 
 createBumps(avoidClasses(clWater, 2, clPlayer, 20));
 RMS.SetProgress(60);
 
 log("Creating hills...");
 createHills(
 	[tPrimary, tPrimary, tSecondary],
 	avoidClasses(clPlayer, 20, clHill, 35),
 	clHill, scaleByMapSize(20, 240));
 RMS.SetProgress(65);
 
 log("Creating dirt patches...");
 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...");
 	createMines(
 	[
 		[new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)],
 		[new SimpleObject(oStoneSmall, 2,5, 1,3)]
 	],
 	avoidClasses(clWater, 3, clPlayer, 20, clRock, 18, clHill, 2)
 );
 
 log("Creating metal mines...");
 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(
 	[
 		[new SimpleObject(aRockMedium, 1,3, 0,1)],
 		[
 			new SimpleObject(aRockLarge, 1,2, 0,1),
 			new SimpleObject(aRockMedium, 1,3, 0,2)
 		]
 	],
 	[
 		scaleByMapSize(16, 262),
 		scaleByMapSize(8, 131),
 	],
-	avoidClasses(clWater, 0, clPlayer, 0)
-);
+	avoidClasses(clWater, 0, clPlayer, 0));
 
 createDecoration(
 	[
 		[new SimpleObject(aIceberg, 1, 1, 1, 1)]
 	],
 	[
 		scaleByMapSize(8, 131)
 	],
-	[stayClasses(clWater, 4), avoidClasses(clHill, 2)]
-);
+	[stayClasses(clWater, 4), avoidClasses(clHill, 2)]);
 RMS.SetProgress(80);
 
 createFood(
 	[
 		[new SimpleObject(oArcticFox, 1,2, 0,3)],
 		[new SimpleObject(oWolf, 4,6, 0,4)],
 		[new SimpleObject(oWalrus, 2,3, 0,2)],
 		[new SimpleObject(oMuskox, 2,3, 0,2)]
 	],
 	[
 		3 * numPlayers,
 		5 * numPlayers,
 		5 * numPlayers,
 		12 * numPlayers
 	],
 	avoidClasses(clPlayer, 35, clFood, 16, clWater, 2, clMetal, 4, clRock, 4, clHill, 2)
 );
 
 createFood(
 	[
 		[new SimpleObject(oWhaleFin, 1,2, 0,2)],
 		[new SimpleObject(oWhaleHumpback, 1,2, 0,2)]
 	],
 	[
 		scaleByMapSize(1, 6) * 3,
 		scaleByMapSize(1, 6) * 3,
 	],
 	[avoidClasses(clFood, 20, clHill, 5), stayClasses(clWater, 6)]
 );
 
 createFood(
 	[
 		[new SimpleObject(oFish, 2,3, 0,2)]
 	],
 	[
 		100
 	],
 	[avoidClasses(clFood, 12, clHill, 5), stayClasses(clWater, 6)]
 );
 RMS.SetProgress(85);
 
 // Create trigger points where wolves spawn
 createObjectGroupsDeprecated(
 	new SimpleGroup([new SimpleObject("trigger/trigger_point_A", 1, 1, 0, 0)], true, clWolf),
 	0,
 	avoidClasses(clWater, 2, clMetal, 4, clRock, 4, clPlayer, 15, clHill, 2, clWolf, 20),
 	1000,
-	100
-);
+	100);
 RMS.SetProgress(95);
 
 if (randBool(1/3))
 {
 	setSkySet("sunset 1");
 	setSunColor(0.8, 0.7, 0.6);
 	setTerrainAmbientColor(0.7, 0.6, 0.7);
 	setUnitsAmbientColor(0.6, 0.5, 0.6);
 	setSunElevation(randFloat(PI/24, PI/7));
 }
 else
 {
 	setSkySet(pickRandom(["cumulus", "rain", "mountainous", "overcast", "rain", "stratus"]));
 	setSunElevation(randFloat(PI/9, PI/7));
 }
 
 setSunRotation(randFloat(0, TWO_PI));
 
 setWaterColor(0.3, 0.3, 0.4);
 setWaterTint(0.75, 0.75, 0.75);
 setWaterMurkiness(0.92);
 setWaterWaviness(0.5);
 setWaterType("clap");
 
 setFogThickness(0.76);
 setFogFactor(0.7);
 
 setPPEffect("hdr");
 setPPContrast(0.6);
 setPPSaturation(0.45);
 setPPBloom(0.4);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/river_archipelago.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/river_archipelago.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/river_archipelago.js	(revision 20301)
@@ -1,551 +1,549 @@
 RMS.LoadLibrary("rmgen");
 
 const tGrass = ["tropic_grass_c", "tropic_grass_c", "tropic_grass_c", "tropic_grass_c", "tropic_grass_plants", "tropic_plants", "tropic_plants_b"];
 const tGrassA = "tropic_plants_c";
 const tGrassB = "tropic_plants_c";
 const tGrassC = "tropic_grass_c";
 const tForestFloor = "tropic_grass_plants";
 const tCliff = ["tropic_cliff_a", "tropic_cliff_a", "tropic_cliff_a", "tropic_cliff_a_plants"];
 const tPlants = "tropic_plants";
 const tRoad = "tropic_citytile_a";
 const tRoadWild = "tropic_citytile_plants";
 const tShoreBlend = "tropic_beach_dry_plants";
 const tShore = "tropic_beach_dry";
 const tWater = "tropic_beach_wet";
 
 const oTree = "gaia/flora_tree_toona";
 const oPalm1 = "gaia/flora_tree_palm_tropic";
 const oPalm2 = "gaia/flora_tree_palm_tropical";
 const oStoneLarge = "gaia/geology_stonemine_tropic_quarry";
 const oStoneSmall = "gaia/geology_stone_tropic_a";
 const oMetalLarge = "gaia/geology_metal_tropic_slabs";
 const oFish = "gaia/fauna_fish";
 const oDeer = "gaia/fauna_deer";
 const oTiger = "gaia/fauna_tiger";
 const oBoar = "gaia/fauna_boar";
 const oPeacock = "gaia/fauna_peacock";
 const oBush = "gaia/flora_bush_berry";
 const oSpearman = "units/maur_infantry_spearman_b";
 const oArcher = "units/maur_infantry_archer_b";
 const oArcherElephant = "units/maur_elephant_archer_b";
 
 const aRockLarge = "actor|geology/stone_granite_large.xml";
 const aRockMedium = "actor|geology/stone_granite_med.xml";
 const aBush1 = "actor|props/flora/plant_tropic_a.xml";
 const aBush2 = "actor|props/flora/plant_lg.xml";
 const aBush3 = "actor|props/flora/plant_tropic_large.xml";
 
 const pForestD = [tForestFloor + TERRAIN_SEPARATOR + oTree, tForestFloor];
 const pForestP1 = [tForestFloor + TERRAIN_SEPARATOR + oPalm1, tForestFloor];
 const pForestP2 = [tForestFloor + TERRAIN_SEPARATOR + oPalm2, tForestFloor];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 
 var clPlayer = createTileClass();
 var clPlayerTerritory = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clGaia = createTileClass();
 var clStrip = [];
 
 var connectPlayers = randBool();
 
 // Map layout
 var stripWidthsLeft = connectPlayers ?
 	[[0.03, 0.09], [0.14, 0.25], [0.36, 0.46]] : 
 	[[0, 0.06], [0.12, 0.23], [0.33, 0.43]];
 
 var playerPosLeft = (stripWidthsLeft[2][0] + stripWidthsLeft[2][1]) / 2;
 
 // Mirror
 var stripWidthsRight = clone(stripWidthsLeft);
 stripWidthsRight.reverse();
 stripWidthsRight = stripWidthsRight.map(strip => [1 - strip[1], 1 - strip[0]]);
 
 var stripWidths = stripWidthsLeft.concat(stripWidthsRight);
 var playerPos = [playerPosLeft, 1 - playerPosLeft];
 
 for (let i = 0; i < stripWidths.length; ++i)
 {
 	clStrip[i] = createTileClass();
 
 	let isPlayerStrip = i == 2 || i == 3;
 	for (let j = 0; j < scaleByMapSize(20, 100); ++j)
 		createArea(
 			new ChainPlacer(
 				1,
 				Math.floor(scaleByMapSize(3, connectPlayers && isPlayerStrip ? 8 : 7)),
 				Math.floor(scaleByMapSize(30, 60)),
 				1,
 				Math.floor(randFloat(...stripWidths[i]) * mapSize),
 				Math.floor(randFloat(0, 1) * mapSize)),
 			[
 				new LayeredPainter([tGrass, tGrass], [2]),
 				new SmoothElevationPainter(ELEVATION_SET, 3, 3),
 				paintClass(clStrip[i])
 			],
 			null);
 }
 RMS.SetProgress(20);
 
 var playerIDs = sortAllPlayers();
 
 // Either left vs right or top vs bottom
 var leftVSRight = randBool();
 
 for (let i = 0; i < numPlayers; ++i)
 {
 	let playerX;
 	let playerZ;
 
 	if (leftVSRight)
 	{
 		let left = i < numPlayers / 2;
 		playerX = playerPos[left ? 0 : 1];
 		playerZ = 2 * (left ? i + 1 : numPlayers - i - 0.5) / (numPlayers + 1 + numPlayers % 2);
 	}
 	else
 	{
 		playerX = playerPos[i % 2];
 		playerZ = (i + 1) / (numPlayers + 1);
 	}
 
 	log("Creating base for player " + playerIDs[i] + "...");
 	let radius = scaleByMapSize(12, 20);
 
 	let fx = fractionToTiles(playerX);
 	let fz = fractionToTiles(playerZ);
 	let ix = Math.round(fx);
 	let iz = Math.round(fz);
 
 	addCivicCenterAreaToClass(ix, iz, clPlayer);
 
 	// Create the main island
 	createArea(
 		new ChainPlacer(1, 6, 40, 1, ix, iz, 0, [Math.floor(radius)]),
 		[
 			new LayeredPainter([tGrass, tGrass, tGrass], [1, 4]),
 			new SmoothElevationPainter(ELEVATION_SET, 3, 4),
 			paintClass(clPlayerTerritory)
 		], null);
 
 	// Create the city patch
 	let cityRadius = radius / 3;
 	createArea(
 		new ClumpPlacer(PI * cityRadius * cityRadius, 0.6, 0.3, 10, ix, iz),
 		new LayeredPainter([tRoadWild, tRoad], [1]),
 		null);
 
 	placeCivDefaultEntities(fx, fz, playerIDs[i],  { 'iberWall': 'towers' });
 
 	placeDefaultChicken(fx, fz, clBaseResource, undefined, oPeacock);
 
 	// Create berry bushes
 	let angle = randFloat(0, 2 * PI);
 	let dist = 12;
 	createObjectGroup(
 		new SimpleGroup(
 			[new SimpleObject(oBush, 5, 5, 0, 3)],
 			true,
 			clBaseResource,
 			Math.round(fx + dist * Math.cos(angle)),
 			Math.round(fz + dist * Math.sin(angle))),
 		0);
 
 	// Create metal mine
 	angle += randFloat(PI/8, PI/4);
 	createObjectGroup(
 		new SimpleGroup(
 			[new SimpleObject(oMetalLarge, 1, 1, 0, 0)],
 			true,
 			clBaseResource,
 			Math.round(fx + dist * Math.cos(angle)),
 			Math.round(fz + dist * Math.sin(angle))),
 		0);
 
 	// Create stone mines
 	angle += randFloat(PI/8, PI/4);
 	createObjectGroup(
 		new SimpleGroup(
 			[new SimpleObject(oStoneLarge, 1, 1, 0, 2)],
 			true,
 			clBaseResource,
 			Math.round(fx + dist * Math.cos(angle)),
 			Math.round(fz + dist * Math.sin(angle))),
 		0);
 
 	// Create starting trees
 	let num = 40;
 	let tAngle = randFloat(-PI/3, 4*PI/3);
 	let tDist = randFloat(12, 13);
 	createObjectGroup(
 		new SimpleGroup(
 			[new SimpleObject(oTree, num, num, 0, 3)],
 			false,
 			clBaseResource,
 			Math.round(fx + tDist * Math.cos(tAngle)),
 			Math.round(fz + tDist * Math.sin(tAngle))),
 		0,
 		avoidClasses(clBaseResource, 2));
 }
 RMS.SetProgress(35);
 
 log("Creating gaia...");
 for (let i = 0; i < 2; ++i)
 	for (let j = 0; j < scaleByMapSize(1, 8); ++j)
 		createObjectGroupsDeprecated(
 			new SimpleGroup(
 				[
 					new SimpleObject(oSpearman, 8, 12, 2, 3),
 					new SimpleObject(oArcher, 8, 12, 2, 3),
 					new SimpleObject(oArcherElephant, 2, 3, 4, 5)
 				],
 				true,
 				clGaia),
 			0,
 			[
 				avoidClasses(
 					clWater, 2,
 					clForest, 1,
 					clPlayerTerritory, 0,
 					clHill, 1,
 					clGaia, 15),
 				stayClasses(clStrip[i == 0 ? 0 : stripWidths.length - 1], 1)
 			],
 			scaleByMapSize(5, 10),
 			50);
 
 paintTerrainBasedOnHeight(-10, 0, 1, tWater);
 paintTileClassBasedOnHeight(-10, 0, 1, clWater);
 paintTerrainBasedOnHeight(1, 2.8, 1, tShoreBlend);
 paintTerrainBasedOnHeight(0, 1, 1, tShore);
 RMS.SetProgress(40);
 
 log("Creating hills...");
 createAreas(
 	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(
 			clPlayerTerritory, 0,
 			clHill, 5,
 			clGaia, 1,
 			clWater, 2)
 	],
 	scaleByMapSize(1, 5));
 
 log("Creating bumps...");
 createBumps(avoidClasses(clPlayer, 8, clWater, 2), scaleByMapSize(20, 150), 2, 8, 4, 1, 4);
 RMS.SetProgress(50);
 
 log("Creating forests...");
 var P_FOREST = 0.7;
 var totalTrees = scaleByMapSize(1000, 4000);
 var numForest = totalTrees * P_FOREST;
 var numStragglers = totalTrees * (1.0 - P_FOREST);
 
 var types = [
 	[[tGrass, tGrass, tGrass, tGrass, pForestD], [tGrass, tGrass, tGrass, pForestD]],
 	[[tGrass, tGrass, tGrass, tGrass, pForestP1], [tGrass, tGrass, tGrass, pForestP1]],
 	[[tGrass, tGrass, tGrass, tGrass, pForestP2], [tGrass, tGrass, tGrass, pForestP2]]
 ];
 var size = numForest / (scaleByMapSize(3, 6) * numPlayers);
 var num = Math.floor(size / types.length);
 for (let type of types)
 	createAreas(
 		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, 12,
 			clForest, 6,
 			clHill, 0,
 			clGaia, 1,
 			clWater, 2),
 		num);
 
 log("Creating straggler trees...");
 var types = [oTree, oPalm1, oPalm2];
 var num = Math.floor(numStragglers / types.length);
 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, 8,
 			clBaseResource, 4,
 			clGaia, 1,
 			clMetal, 4,
 			clRock, 4),
 		num);
 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)
 		],
 		avoidClasses(
 			clWater, 8,
 			clForest, 0,
 			clHill, 0,
 			clGaia, 1,
 			clPlayerTerritory, 0,
 			clDirt, 16),
 		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)
 		],
 		avoidClasses(
 			clWater, 8,
 			clForest, 0,
 			clHill, 0,
 			clGaia, 1,
 			clPlayerTerritory, 0,
 			clDirt, 16),
 		scaleByMapSize(20, 80));
 
 log("Creating stone mines...");
 createObjectGroupsDeprecated(
 	new SimpleGroup(
 		[
 			new SimpleObject(oStoneSmall, 0, 2, 0, 4),
 			new SimpleObject(oStoneLarge, 1, 1, 0, 4)
 		],
 		true,
 		clRock),
 	0,
 	avoidClasses(
 		clWater, 3,
 		clForest, 1,
 		clPlayerTerritory, 0,
 		clGaia, 1,
 		clRock, 10,
 		clHill, 1),
 		9 * scaleByMapSize(1, 4),
 		100);
 
 log("Creating small stone mines...");
 createObjectGroupsDeprecated(
 	new SimpleGroup([new SimpleObject(oStoneSmall, 2, 5, 1, 3)], true, clRock),
 	0,
 	avoidClasses(
 		clWater, 4,
 		clForest, 1,
 		clPlayerTerritory, 0,
 		clGaia, 1,
 		clRock, 10,
 		clHill, 1),
 		9 * scaleByMapSize(1, 4),
 	100);
 
 log("Creating metal mines...");
 createObjectGroupsDeprecated(
 	new SimpleGroup([new SimpleObject(oMetalLarge, 1, 1, 0, 4)], true, clMetal),
 	0,
 	avoidClasses(
 		clWater, 4,
 		clForest, 1,
 		clPlayerTerritory, 0,
 		clGaia, 1,
 		clMetal, 10,
 		clRock, 5,
 		clHill, 1),
 	9 * scaleByMapSize(1, 4),
 	100);
 
 log("Creating small decorative rocks...");
 createObjectGroupsDeprecated(
 	new SimpleGroup([new SimpleObject(aRockMedium, 1, 3, 0, 1)], true),
 	0,
 	avoidClasses(
 		clWater, 2,
 		clForest, 1,
 		clGaia, 1,
 		clPlayer, 8,
 		clBaseResource, 4,
 		clHill, 0),
 	3 * scaleByMapSize(16, 262),
 	50);
 
 log("Creating large decorative rocks...");
 createObjectGroupsDeprecated(
 	new SimpleGroup([
 			new SimpleObject(aRockLarge, 1, 2, 0, 1),
 			new SimpleObject(aRockMedium, 1, 3, 0, 2)
 		],
 		true),
 	0,
 	avoidClasses(
 		clWater, 2,
 		clForest, 1,
 		clGaia, 1,
 		clPlayer, 8,
 		clBaseResource, 4,
 		clHill, 0),
 	3 * scaleByMapSize(8, 131),
 	50);
 
 log("Creating small grass tufts...");
 createObjectGroupsDeprecated(
 	new SimpleGroup([new SimpleObject(aBush1, 1, 2, 0, 1, -PI/8, PI/8)]),
 	0,
 	avoidClasses(
 		clWater, 4,
 		clHill, 2,
 		clPlayer, 8,
 		clGaia, 1,
 		clBaseResource, 4,
 		clDirt, 0),
 	8 * scaleByMapSize(13, 200));
 RMS.SetProgress(70);
 
 log("Creating large grass tufts...");
 	createObjectGroupsDeprecated(
 		new SimpleGroup([
 			new SimpleObject(aBush2, 2, 4, 0, 1.8, -PI/8, PI/8),
 			new SimpleObject(aBush1, 3, 6, 1.2, 2.5, -PI/8, PI/8)
 		]),
 		0,
 		avoidClasses(
 			clWater, 4,
 			clHill, 2,
 			clGaia, 1,
 			clPlayer, 8,
 			clBaseResource, 4,
 			clDirt, 1,
 			clForest, 0),
 		8 * scaleByMapSize(13, 200));
 RMS.SetProgress(85);
 
 log("Creating bushes...");
 	createObjectGroupsDeprecated(
 		new SimpleGroup([
 			new SimpleObject(aBush3, 1, 2, 0, 2),
 			new SimpleObject(aBush2, 2, 4, 0, 2)
 		]), 0,
 		avoidClasses(
 			clWater, 4,
 			clHill, 1,
 			clPlayerTerritory, 0,
 			clGaia, 1,
 			clDirt, 1),
 		8 * scaleByMapSize(13, 200), 50);
 
 log("Creating deer...");
 	createObjectGroupsDeprecated(
 		new SimpleGroup([new SimpleObject(oDeer, 5, 7, 0, 4)], true, clFood),
 		0,
 		avoidClasses(
 			clWater, 4,
 			clForest, 0,
 			clPlayerTerritory, 0,
 			clGaia, 1,
 			clHill, 1,
 			clFood, 20),
 		3 * numPlayers,
 		50);
 
 log("Creating boar...");
 	createObjectGroupsDeprecated(
 		new SimpleGroup([new SimpleObject(oBoar, 2, 4, 0, 4)], true, clFood),
 		0,
 		avoidClasses(
 			clWater, 4,
 			clForest, 0,
 			clPlayerTerritory, 0,
 			clGaia, 1,
 			clHill, 1,
 			clFood, 20),
 		3 * numPlayers,
 		50);
 
 log("Creating tigers...");
 createObjectGroupsDeprecated(
 	new SimpleGroup([new SimpleObject(oTiger, 1, 1, 0, 4)], true, clFood),
 	0,
 	avoidClasses(
 		clWater, 4,
 		clForest, 0,
 		clPlayerTerritory, 0,
 		clGaia, 1,
 		clHill, 1,
 		clFood, 20),
 	3 * numPlayers,
 	50);
 RMS.SetProgress(95);
 
 log("Creating berry bush...");
 createObjectGroupsDeprecated(
 	new SimpleGroup([new SimpleObject(oBush, 5, 7, 0, 4)], true, clFood),
 	0,
 	avoidClasses(
 		clWater, 4,
 		clForest, 0,
 		clPlayerTerritory, 0,
 		clGaia, 1,
 		clHill, 1,
 		clFood, 10),
 		randIntInclusive(1, 4) * numPlayers + 2,
 		50);
 
 log("Creating fish...");
 createObjectGroupsDeprecated(
 	new SimpleGroup([new SimpleObject(oFish, 2, 3, 0, 2)], true, clFood),
 	0,
 	[avoidClasses(clFood, 15), stayClasses(clWater, 4)],
 	200,
 	100);
 
 setSunColor(0.6, 0.6, 0.6);
 setSunElevation(PI/ 3);
 
 setWaterColor(0.424, 0.534, 0.639);
 setWaterTint(0.369, 0.765, 0.745);
 setWaterWaviness(1.0);
 setWaterType("default");
 setWaterMurkiness(0.35);
 
 setFogFactor(0.03);
 setFogThickness(0.2);
 
 setPPEffect("hdr");
 setPPContrast(0.7);
 setPPSaturation(0.65);
 setPPBloom(0.6);
 
 setSkySet("stratus");
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/rmgen2/gaia.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/rmgen2/gaia.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/rmgen2/gaia.js	(revision 20301)
@@ -1,1271 +1,1266 @@
 var g_Props = {
 	"barrels": "actor|props/special/eyecandy/barrels_buried.xml",
 	"crate": "actor|props/special/eyecandy/crate_a.xml",
 	"cart": "actor|props/special/eyecandy/handcart_1_broken.xml",
 	"well": "actor|props/special/eyecandy/well_1_c.xml",
 	"skeleton": "actor|props/special/eyecandy/skeleton.xml",
 };
 
 /**
  * Create bluffs, i.e. a slope hill reachable from ground level.
  * Fill it with wood, mines, animals and decoratives.
  *
  * @param {Array} constraint - where to place them
  * @param {number} size - size of the bluffs (1.2 would be 120% of normal)
  * @param {number} deviation - degree of deviation from the defined size (0.2 would be 20% plus/minus)
  * @param {number} fill - size of map to fill (1.5 would be 150% of normal)
  * @param {number} baseHeight - elevation of the floor, making the bluff reachable
  */
 function addBluffs(constraint, size, deviation, fill, baseHeight)
 {
 	var constrastTerrain = g_Terrains.tier2Terrain;
 
 	if (currentBiome() == "tropic")
 		constrastTerrain = g_Terrains.dirt;
 
 	if (currentBiome() == "autumn")
 		constrastTerrain = g_Terrains.tier3Terrain;
 
 	var count = fill * 15;
 	var minSize = 5;
 	var maxSize = 7;
 	var elevation = 30;
 	var spread = 100;
 
 	for (var i = 0; i < count; ++i)
 	{
 		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)
 			continue;
 
 		var points = rendered[0].points;
 
 		var corners = findCorners(points);
 
 		// Seed an array the size of the bounding box
 		var bb = createBoundingBox(points, corners);
 
 		// Get a random starting position for the baseline and the endline
 		var angle = randIntInclusive(0, 3);
 		var opAngle = angle - 2;
 		if (angle < 2)
 			opAngle = angle + 2;
 
 		// Find the edges of the bluff
 		var baseLine;
 		var endLine;
 
 		// If we can't access the bluff, try different angles
 		var retries = 0;
 		var bluffCat = 2;
 		while (bluffCat != 0 && retries < 5)
 		{
 			baseLine = findClearLine(bb, corners, angle, baseHeight);
 			endLine = findClearLine(bb, corners, opAngle, baseHeight);
 
 			bluffCat = unreachableBluff(bb, corners, baseLine, endLine);
 			++angle;
 			if (angle > 3)
 				angle = 0;
 
 			opAngle = angle - 2;
 			if (angle < 2)
 				opAngle = angle + 2;
 
 			++retries;
 		}
 
 		// Inaccessible, turn it into a plateau
 		if (bluffCat > 0)
 		{
 			removeBluff(points);
 			continue;
 		}
 
 		// Create an entrance area by using a small margin
 		var margin = 0.08;
 		var ground = createTerrain(g_Terrains.mainTerrain);
 		var slopeLength = (1 - margin) * getDistance(baseLine.midX, baseLine.midZ, endLine.midX, endLine.midZ);
 
 		// Adjust the height of each point in the bluff
 		for (var p = 0; p < points.length; ++p)
 		{
 			var pt = points[p];
 			var dist = distanceOfPointFromLine(baseLine.x1, baseLine.z1, baseLine.x2, baseLine.z2, pt.x, pt.z);
 
 			var curHeight = g_Map.getHeight(pt.x, pt.z);
 			var newHeight = curHeight - curHeight * (dist / slopeLength) - 2;
 
 			newHeight = Math.max(newHeight, endLine.height);
 
 			if (newHeight <= endLine.height + 2 && g_Map.validT(pt.x, pt.z) && g_Map.getTexture(pt.x, pt.z).indexOf('cliff') > -1)
 				ground.place(pt.x, pt.z);
 
 			g_Map.setHeight(pt.x, pt.z, newHeight);
 		}
 
 		// Smooth out the ground around the bluff
 		fadeToGround(bb, corners.minX, corners.minZ, endLine.height);
 	}
 
 	addElements([
 		{
 			"func": addHills,
 			"avoid": [
 				g_TileClasses.hill, 3,
 				g_TileClasses.player, 20,
 				g_TileClasses.valley, 2,
 				g_TileClasses.water, 2
 			],
 			"stay": [g_TileClasses.bluff, 3],
 			"sizes": g_AllSizes,
 			"mixes": g_AllMixes,
 			"amounts": g_AllAmounts
 		}
 	]);
 
 	addElements([
 		{
 			"func": addLayeredPatches,
 			"avoid": [
 				g_TileClasses.dirt, 5,
 				g_TileClasses.forest, 2,
 				g_TileClasses.mountain, 2,
 				g_TileClasses.player, 12,
 				g_TileClasses.water, 3
 			],
 			"stay": [g_TileClasses.bluff, 5],
 			"sizes": ["normal"],
 			"mixes": ["normal"],
 			"amounts": ["normal"]
 		}
 	]);
 
 	addElements([
 		{
 			"func": addDecoration,
 			"avoid": [
 				g_TileClasses.forest, 2,
 				g_TileClasses.player, 12,
 				g_TileClasses.water, 3
 			],
 			"stay": [g_TileClasses.bluff, 5],
 			"sizes": ["normal"],
 			"mixes": ["normal"],
 			"amounts": ["normal"]
 		}
 	]);
 
 	addElements([
 		{
 			"func": addProps,
 			"avoid": [
 				g_TileClasses.forest, 2,
 				g_TileClasses.player, 12,
 				g_TileClasses.prop, 40,
 				g_TileClasses.water, 3
 			],
 			"stay": [
 				g_TileClasses.bluff, 7,
 				g_TileClasses.mountain, 7
 			],
 			"sizes": ["normal"],
 			"mixes": ["normal"],
 			"amounts": ["scarce"]
 		}
 	]);
 
 	addElements(shuffleArray([
 		{
 			"func": addForests,
 			"avoid": [
 				g_TileClasses.berries, 5,
 				g_TileClasses.forest, 18,
 				g_TileClasses.metal, 5,
 				g_TileClasses.mountain, 5,
 				g_TileClasses.player, 20,
 				g_TileClasses.rock, 5,
 				g_TileClasses.water, 2
 			],
 			"stay": [g_TileClasses.bluff, 6],
 			"sizes": g_AllSizes,
 			"mixes": g_AllMixes,
 			"amounts": ["normal", "many", "tons"]
 		},
 		{
 			"func": addMetal,
 			"avoid": [
 				g_TileClasses.berries, 5,
 				g_TileClasses.forest, 5,
 				g_TileClasses.mountain, 2,
 				g_TileClasses.player, 50,
 				g_TileClasses.rock, 15,
 				g_TileClasses.metal, 40,
 				g_TileClasses.water, 3
 			],
 			"stay": [g_TileClasses.bluff, 6],
 			"sizes": ["normal"],
 			"mixes": ["same"],
 			"amounts": ["normal"]
 		},
 		{
 			"func": addStone,
 			"avoid": [
 				g_TileClasses.berries, 5,
 				g_TileClasses.forest, 5,
 				g_TileClasses.mountain, 2,
 				g_TileClasses.player, 50,
 				g_TileClasses.rock, 40,
 				g_TileClasses.metal, 15,
 				g_TileClasses.water, 3
 			],
 			"stay": [g_TileClasses.bluff, 6],
 			"sizes": ["normal"],
 			"mixes": ["same"],
 			"amounts": ["normal"]
 		}
 	]));
 
 	let savanna = currentBiome() == "savanna";
 	addElements(shuffleArray([
 		{
 			"func": addStragglerTrees,
 			"avoid": [
 				g_TileClasses.berries, 5,
 				g_TileClasses.forest, 10,
 				g_TileClasses.metal, 5,
 				g_TileClasses.mountain, 1,
 				g_TileClasses.player, 12,
 				g_TileClasses.rock, 5,
 				g_TileClasses.water, 5
 			],
 			"stay": [g_TileClasses.bluff, 6],
 			"sizes": savanna ? ["big"] : g_AllSizes,
 			"mixes": savanna ? ["varied"] : g_AllMixes,
 			"amounts": savanna ? ["tons"] : ["normal", "many", "tons"]
 		},
 		{
 			"func": addAnimals,
 			"avoid": [
 				g_TileClasses.animals, 20,
 				g_TileClasses.forest, 5,
 				g_TileClasses.mountain, 1,
 				g_TileClasses.player, 20,
 				g_TileClasses.rock, 5,
 				g_TileClasses.metal, 5,
 				g_TileClasses.water, 3
 			],
 			"stay": [g_TileClasses.bluff, 6],
 			"sizes": g_AllSizes,
 			"mixes": g_AllMixes,
 			"amounts": ["normal", "many", "tons"]
 		},
 		{
 			"func": addBerries,
 			"avoid": [
 				g_TileClasses.berries, 50,
 				g_TileClasses.forest, 5,
 				g_TileClasses.metal, 10,
 				g_TileClasses.mountain, 2,
 				g_TileClasses.player, 20,
 				g_TileClasses.rock, 10,
 				g_TileClasses.water, 3
 			],
 			"stay": [g_TileClasses.bluff, 6],
 			"sizes": g_AllSizes,
 			"mixes": g_AllMixes,
 			"amounts": ["normal", "many", "tons"]
 		}
 	]));
 }
 
 /**
  * Add grass, rocks and bushes.
  */
 function addDecoration(constraint, size, deviation, fill)
 {
 	var offset = getRandomDeviation(size, deviation);
 	var decorations = [
 		[
 			new SimpleObject(g_Decoratives.rockMedium, offset, 3 * offset, 0, offset)
 		],
 		[
 			new SimpleObject(g_Decoratives.rockLarge, offset, 2 * offset, 0, offset),
 			new SimpleObject(g_Decoratives.rockMedium, offset, 3 * offset, 0, 2 * offset)
 		],
 		[
 			new SimpleObject(g_Decoratives.grassShort, offset, 2 * offset, 0, offset)
 		],
 		[
 			new SimpleObject(g_Decoratives.grass, 2 * offset, 4 * offset, 0, 1.8 * offset),
 			new SimpleObject(g_Decoratives.grassShort, 3 * offset, 6 * offset, 1.2 * offset, 2.5 * offset)
 		],
 		[
 			new SimpleObject(g_Decoratives.bushMedium, offset, 2 * offset, 0, 2 * offset),
 			new SimpleObject(g_Decoratives.bushSmall, 2 * offset, 4 * offset, 0, 2 * offset)
 		]
 	];
 
 	var baseCount = 1;
 	if (currentBiome() == "tropic")
 		baseCount = 8;
 
 	var counts = [
 		scaleByMapSize(16, 262),
 		scaleByMapSize(8, 131),
 		baseCount * scaleByMapSize(13, 200),
 		baseCount * scaleByMapSize(13, 200),
 		baseCount * scaleByMapSize(13, 200)
 	];
 
 	for (var i = 0; i < decorations.length; ++i)
 	{
 		var decorCount = Math.floor(counts[i] * fill);
 		var group = new SimpleGroup(decorations[i], true);
 		createObjectGroupsDeprecated(group, 0, constraint, decorCount, 5);
 	}
 }
 
 /**
  * Create varying elevations.
  *
  * @param {Array} constraint - avoid/stay-classes
  *
  * @param {Object} el - the element to be rendered, for example:
  *  "class": g_TileClasses.hill,
  *	"painter": [g_Terrains.mainTerrain, g_Terrains.mainTerrain],
  *	"size": 1,
  *	"deviation": 0.2,
  *	"fill": 1,
  *	"count": scaleByMapSize(4, 8),
  *	"minSize": Math.floor(scaleByMapSize(3, 8)),
  *	"maxSize": Math.floor(scaleByMapSize(5, 10)),
  *	"spread": Math.floor(scaleByMapSize(10, 20)),
  *	"minElevation": 6,
  *	"maxElevation": 12,
  *	"steepness": 1.5
  */
 
 function addElevation(constraint, el)
 {
 	var count = el.fill * el.count;
 	var minSize = el.minSize;
 	var maxSize = el.maxSize;
 	var spread = el.spread;
 
 	var elType = ELEVATION_MODIFY;
 	if (el.class == g_TileClasses.water)
 		elType = ELEVATION_SET;
 
 	var widths = [];
 
 	// Allow for shore and cliff rendering
 	for (var s = el.painter.length; s > 2; --s)
 		widths.push(1);
 
 	for (var i = 0; i < count; ++i)
 	{
 		var elevation = randIntExclusive(el.minElevation, el.maxElevation);
 		var smooth = Math.floor(elevation / el.steepness);
 
 		var offset = getRandomDeviation(el.size, el.deviation);
 		var pMinSize = Math.floor(minSize * offset);
 		var pMaxSize = Math.floor(maxSize * offset);
 		var pSpread = Math.floor(spread * offset);
 		var pSmooth = Math.abs(Math.floor(smooth * offset));
 		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);
 	}
 }
 
 /**
  * Create rolling hills.
  */
 function addHills(constraint, size, deviation, fill)
 {
 	addElevation(constraint, {
 		"class": g_TileClasses.hill,
 		"painter": [g_Terrains.mainTerrain, g_Terrains.mainTerrain],
 		"size": size,
 		"deviation": deviation,
 		"fill": fill,
 		"count": 8,
 		"minSize": 5,
 		"maxSize": 8,
 		"spread": 20,
 		"minElevation": 6,
 		"maxElevation": 12,
 		"steepness": 1.5
 	});
 }
 
 /**
  * Create random lakes with fish in it.
  */
 function addLakes(constraint, size, deviation, fill)
 {
 	var lakeTile = g_Terrains.water;
 
 	if (currentBiome() == "temperate" || currentBiome() == "tropic")
 		lakeTile = g_Terrains.dirt;
 
 	if (currentBiome() == "mediterranean")
 		lakeTile = g_Terrains.tier2Terrain;
 
 	if (currentBiome() == "autumn")
 		lakeTile = g_Terrains.shore;
 
 	addElevation(constraint, {
 		"class": g_TileClasses.water,
 		"painter": [lakeTile, lakeTile],
 		"size": size,
 		"deviation": deviation,
 		"fill": fill,
 		"count": 6,
 		"minSize": 7,
 		"maxSize": 9,
 		"spread": 70,
 		"minElevation": -15,
 		"maxElevation": -2,
 		"steepness": 1.5
 	});
 
 	addElements([
 		{
 			"func": addFish,
 			"avoid": [
 				g_TileClasses.fish, 12,
 				g_TileClasses.hill, 8,
 				g_TileClasses.mountain, 8,
 				g_TileClasses.player, 8
 			],
 			"stay": [g_TileClasses.water, 7],
 			"sizes": g_AllSizes,
 			"mixes": g_AllMixes,
 			"amounts": ["normal", "many", "tons"]
 		}
 	]);
 
 	var group = new SimpleGroup([new SimpleObject(g_Decoratives.rockMedium, 1, 3, 1, 3)], true, g_TileClasses.dirt);
 	createObjectGroupsDeprecated(group, 0, [stayClasses(g_TileClasses.water, 1), borderClasses(g_TileClasses.water, 4, 3)], 1000, 100);
 
 	group = new SimpleGroup([new SimpleObject(g_Decoratives.reeds, 10, 15, 1, 3), new SimpleObject(g_Decoratives.rockMedium, 1, 3, 1, 3)], true, g_TileClasses.dirt);
 	createObjectGroupsDeprecated(group, 0, [stayClasses(g_TileClasses.water, 2), borderClasses(g_TileClasses.water, 4, 3)], 1000, 100);
 }
 
 /**
  * Universal function to create layered patches.
  */
 function addLayeredPatches(constraint, size, deviation, fill)
 {
 	var minRadius = 1;
 	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);
 	}
 }
 
 /**
  * Create steep mountains.
  */
 function addMountains(constraint, size, deviation, fill)
 {
 	addElevation(constraint, {
 		"class": g_TileClasses.mountain,
 		"painter": [g_Terrains.cliff, g_Terrains.hill],
 		"size": size,
 		"deviation": deviation,
 		"fill": fill,
 		"count": 8,
 		"minSize": 2,
 		"maxSize": 4,
 		"spread": 100,
 		"minElevation": 100,
 		"maxElevation": 120,
 		"steepness": 4
 	});
 }
 
 /**
  * Create plateaus.
  */
 function addPlateaus(constraint, size, deviation, fill)
 {
 	var plateauTile = g_Terrains.dirt;
 
 	if (currentBiome() == "snowy")
 		plateauTile = g_Terrains.tier1Terrain;
 
 	if (currentBiome() == "alpine" || currentBiome() == "savanna")
 		plateauTile = g_Terrains.tier2Terrain;
 
 	if (currentBiome() == "autumn")
 		plateauTile = g_Terrains.tier4Terrain;
 
 	addElevation(constraint, {
 		"class": g_TileClasses.plateau,
 		"painter": [g_Terrains.cliff, plateauTile],
 		"size": size,
 		"deviation": deviation,
 		"fill": fill,
 		"count": 15,
 		"minSize": 2,
 		"maxSize": 4,
 		"spread": 200,
 		"minElevation": 20,
 		"maxElevation": 30,
 		"steepness": 8
 	});
 
 	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([
 		{
 			"func": addDecoration,
 			"avoid": [
 				g_TileClasses.dirt, 15,
 				g_TileClasses.forest, 2,
 				g_TileClasses.player, 12,
 				g_TileClasses.water, 3
 			],
 			"stay": [g_TileClasses.plateau, 8],
 			"sizes": ["normal"],
 			"mixes": ["normal"],
 			"amounts": ["tons"]
 		},
 		{
 			"func": addProps,
 			"avoid": [
 				g_TileClasses.forest, 2,
 				g_TileClasses.player, 12,
 				g_TileClasses.prop, 40,
 				g_TileClasses.water, 3
 			],
 			"stay": [g_TileClasses.plateau, 8],
 			"sizes": ["normal"],
 			"mixes": ["normal"],
 			"amounts": ["scarce"]
 		}
 	]);
 }
 
 /**
  * Place less usual decoratives like barrels or crates.
  */
 function addProps(constraint, size, deviation, fill)
 {
 	var offset = getRandomDeviation(size, deviation);
 
 	var props = [
 		[
 			new SimpleObject(g_Props.skeleton, offset, 5 * offset, 0, 3 * offset + 2),
 		],
 		[
 			new SimpleObject(g_Props.barrels, offset, 2 * offset, 2, 3 * offset + 2),
 			new SimpleObject(g_Props.cart, 0, offset, 5, 2.5 * offset + 5),
 			new SimpleObject(g_Props.crate, offset, 2 * offset, 2, 2 * offset + 2),
 			new SimpleObject(g_Props.well, 0, 1, 2, 2 * offset + 2)
 		]
 	];
 
 	var baseCount = 1;
 
 	var counts = [
 		scaleByMapSize(16, 262),
 		scaleByMapSize(8, 131),
 		baseCount * scaleByMapSize(13, 200),
 		baseCount * scaleByMapSize(13, 200),
 		baseCount * scaleByMapSize(13, 200)
 	];
 
 	// Add small props
 	for (var i = 0; i < props.length; ++i)
 	{
 		var propCount = Math.floor(counts[i] * fill);
 		var group = new SimpleGroup(props[i], true);
 		createObjectGroupsDeprecated(group, 0, constraint, propCount, 5);
 	}
 
 	// Add decorative trees
 	var trees = new SimpleObject(g_Decoratives.tree, 5 * offset, 30 * offset, 2, 3 * offset + 10);
 	createObjectGroupsDeprecated(new SimpleGroup([trees], true), 0, constraint, counts[0] * 5 * fill, 5);
 }
 
 function addValleys(constraint, size, deviation, fill, baseHeight)
 {
 	if (baseHeight < 6)
 		return;
 
 	let minElevation = Math.max(-baseHeight, 1 - baseHeight / (size * (deviation + 1)));
 
 	var valleySlope = g_Terrains.tier1Terrain;
 	var valleyFloor = g_Terrains.tier4Terrain;
 
 	if (currentBiome() == "desert")
 	{
 		valleySlope = g_Terrains.tier3Terrain;
 		valleyFloor = g_Terrains.dirt;
 	}
 
 	if (currentBiome() == "mediterranean")
 	{
 		valleySlope = g_Terrains.tier2Terrain;
 		valleyFloor = g_Terrains.dirt;
 	}
 
 	if (currentBiome() == "alpine" || currentBiome() == "savanna")
 		valleyFloor = g_Terrains.tier2Terrain;
 
 	if (currentBiome() == "tropic")
 		valleySlope = g_Terrains.dirt;
 
 	if (currentBiome() == "autumn")
 		valleyFloor = g_Terrains.tier3Terrain;
 
 	addElevation(constraint, {
 		"class": g_TileClasses.valley,
 		"painter": [valleySlope, valleyFloor],
 		"size": size,
 		"deviation": deviation,
 		"fill": fill,
 		"count": 8,
 		"minSize": 5,
 		"maxSize": 8,
 		"spread": 30,
 		"minElevation": minElevation,
 		"maxElevation": -2,
 		"steepness": 4
 	});
 }
 
 /**
  * Create huntable animals.
  */
 function addAnimals(constraint, size, deviation, fill)
 {
 	var groupOffset = getRandomDeviation(size, deviation);
 
 	var animals = [
 		[new SimpleObject(g_Gaia.mainHuntableAnimal, 5 * groupOffset, 7 * groupOffset, 0, 4 * groupOffset)],
 		[new SimpleObject(g_Gaia.secondaryHuntableAnimal, 2 * groupOffset, 3 * groupOffset, 0, 2 * groupOffset)]
 	];
 
 	for (let animal of animals)
 		createObjectGroupsDeprecated(
 			new SimpleGroup(animal, true, g_TileClasses.animals),
 			0,
 			constraint,
 			Math.floor(30 * fill),
 			50);
 }
 
 function addBerries(constraint, size, deviation, fill)
 {
 	let groupOffset = getRandomDeviation(size, deviation);
 
 	createObjectGroupsDeprecated(
 		new SimpleGroup([new SimpleObject(g_Gaia.fruitBush, 5 * groupOffset, 5 * groupOffset, 0, 3 * groupOffset)], true, g_TileClasses.berries),
 		0,
 		constraint,
 		Math.floor(50 * fill),
 		40);
 }
 
 function addFish(constraint, size, deviation, fill)
 {
 	var groupOffset = getRandomDeviation(size, deviation);
 
 	var fishes = [
 		[new SimpleObject(g_Gaia.fish, groupOffset, 2 * groupOffset, 0, 2 * groupOffset)],
 		[new SimpleObject(g_Gaia.fish, 2 * groupOffset, 4 * groupOffset, 10 * groupOffset, 20 * groupOffset)]
 	];
 
 	for (let fish of fishes)
 		createObjectGroupsDeprecated(
 			new SimpleGroup(fish, true, g_TileClasses.fish),
 			0,
 			constraint,
 			Math.floor(40 * fill),
 			50);
 }
 
 function addForests(constraint, size, deviation, fill)
 {
 	if (currentBiome() == "savanna")
 		return;
 
 	let treeTypes = [
 		[
 			g_Terrains.forestFloor2 + TERRAIN_SEPARATOR + g_Gaia.tree1,
 			g_Terrains.forestFloor2 + TERRAIN_SEPARATOR + g_Gaia.tree2,
 			g_Terrains.forestFloor2
 		],
 		[
 			g_Terrains.forestFloor1 + TERRAIN_SEPARATOR + g_Gaia.tree4,
 			g_Terrains.forestFloor1 + TERRAIN_SEPARATOR + g_Gaia.tree5,
 			g_Terrains.forestFloor1
 		]
 	];
 
 	let forestTypes = [
 		[
 			[g_Terrains.forestFloor2, g_Terrains.mainTerrain, treeTypes[0]],
 			[g_Terrains.forestFloor2, treeTypes[0]]
 		],
 		[
 			[g_Terrains.forestFloor2, g_Terrains.mainTerrain, treeTypes[1]],
 			[g_Terrains.forestFloor1, treeTypes[1]]],
 		[
 			[g_Terrains.forestFloor1, g_Terrains.mainTerrain, treeTypes[0]],
 			[g_Terrains.forestFloor2, treeTypes[0]]],
 		[
 			[g_Terrains.forestFloor1, g_Terrains.mainTerrain, treeTypes[1]],
 			[g_Terrains.forestFloor1, treeTypes[1]]
 		]
 	];
 
 	for (let forestType of forestTypes)
 	{
 		let offset = getRandomDeviation(size, deviation);
 		createAreas(
 			new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5) * offset), Math.floor(50 * offset), 0.5),
 			[
 				new LayeredPainter(forestType, [2]),
 				paintClass(g_TileClasses.forest)
 			],
 			constraint,
 			10 * fill);
 	}
 }
 
 function addMetal(constraint, size, deviation, fill)
 {
 	var offset = getRandomDeviation(size, deviation);
 	createObjectGroupsDeprecated(
 		new SimpleGroup([new SimpleObject(g_Gaia.metalLarge, offset, offset, 0, 4 * offset)], true, g_TileClasses.metal),
 		0,
 		constraint,
 		1 + 20 * fill,
 		100);
 }
 
 function addSmallMetal(constraint, size, mixes, amounts)
 {
 	let deviation = getRandomDeviation(size, mixes);
 	createObjectGroupsDeprecated(
 		new SimpleGroup([new SimpleObject(g_Gaia.metalSmall, 2 * deviation, 5 * deviation, deviation, 3 * deviation)], true, g_TileClasses.metal),
 		0,
 		constraint,
 		1 + 20 * amounts,
 		100);
 }
 
 /**
  * Create stone mines.
  */
 function addStone(constraint, size, deviation, fill)
 {
 	var offset = getRandomDeviation(size, deviation);
 
 	var mines = [
 		[
 			new SimpleObject(g_Gaia.stoneSmall, 0, 2 * offset, 0, 4 * offset),
 			new SimpleObject(g_Gaia.stoneLarge, offset, offset, 0, 4 * offset)
 		],
 		[
 			new SimpleObject(g_Gaia.stoneSmall, 2 * offset, 5 * offset, offset, 3 * offset)
 		]
 	];
 
 	for (let mine of mines)
 		createObjectGroupsDeprecated(
 			new SimpleGroup(mine, true, g_TileClasses.rock),
 			0,
 			constraint,
 			1 + 20 * fill,
 			100);
 }
 
 /**
  * Create straggler trees.
  */
 function addStragglerTrees(constraint, size, deviation, fill)
 {
 	// Ensure minimum distribution on african biome
 	if (currentBiome() == "savanna")
 	{
 		fill = Math.max(fill, 2);
 		size = Math.max(size, 1);
 	}
 
 	var trees = [g_Gaia.tree1, g_Gaia.tree2, g_Gaia.tree3, g_Gaia.tree4];
 
 	var treesPerPlayer = 40;
 	var playerBonus = Math.max(1, (getNumPlayers() - 3) / 2);
 
 	var offset = getRandomDeviation(size, deviation);
 	var treeCount = treesPerPlayer * playerBonus * fill;
 	var totalTrees = scaleByMapSize(treeCount, treeCount);
 
 	var count = Math.floor(totalTrees / trees.length) * fill;
 	var min = offset;
 	var max = 4 * offset;
 	var minDist = offset;
 	var maxDist = 5 * offset;
 
 	// More trees for the african biome
 	if (currentBiome() == "savanna")
 	{
 		min = 3 * offset;
 		max = 5 * offset;
 		minDist = 2 * offset + 1;
 		maxDist = 3 * offset + 2;
 	}
 
 	for (var i = 0; i < trees.length; ++i)
 	{
 		var treesMax = max;
 
 		// Don't clump fruit trees
 		if (i == 2 && (currentBiome() == "desert" || currentBiome() == "mediterranean"))
 			treesMax = 1;
 
 		min = Math.min(min, treesMax);
 
 		var group = new SimpleGroup([new SimpleObject(trees[i], min, treesMax, minDist, maxDist)], true, g_TileClasses.forest);
 		createObjectGroupsDeprecated(group, 0, constraint, count);
 	}
 }
 
 ///////////
 // Terrain Helpers
 ///////////
 
 /**
  * Determine if the endline of the bluff is within the tilemap.
  *
  * @returns {Number} 0 if the bluff is reachable, otherwise a positive number
  */
 function unreachableBluff(bb, corners, baseLine, endLine)
 {
 	// If we couldn't find a slope line
 	if (typeof baseLine.midX === "undefined" || typeof endLine.midX === "undefined")
 		return 1;
 
 	// If the end points aren't on the tilemap
 	if (!g_Map.validT(endLine.x1, endLine.z1) && !g_Map.validT(endLine.x2, endLine.z2))
 		return 2;
 
 	var minTilesInGroup = 1;
 	var insideBluff = false;
 	var outsideBluff = false;
 
 	// If there aren't enough points in each row
 	for (var x = 0; x < bb.length; ++x)
 	{
 		var count = 0;
 		for (var z = 0; z < bb[x].length; ++z)
 		{
 			if (!bb[x][z].isFeature)
 				continue;
 
 			var valid = g_Map.validT(x + corners.minX, z + corners.minZ);
 
 			if (valid)
 				++count;
 
 			if (!insideBluff && valid)
 				insideBluff = true;
 
 			if (outsideBluff && valid)
 				return 3;
 		}
 
 		// We're expecting the end of the bluff
 		if (insideBluff && count < minTilesInGroup)
 			outsideBluff = true;
 	}
 
 	var insideBluff = false;
 	var outsideBluff = false;
 
 	// If there aren't enough points in each column
 	for (var z = 0; z < bb[0].length; ++z)
 	{
 		var count = 0;
 		for (var x = 0; x < bb.length; ++x)
 		{
 			if (!bb[x][z].isFeature)
 				continue;
 
 			var valid = g_Map.validT(x + corners.minX, z + corners.minZ);
 
 			if (valid)
 				++count;
 
 			if (!insideBluff && valid)
 				insideBluff = true;
 
 			if (outsideBluff && valid)
 				return 3;
 		}
 
 		// We're expecting the end of the bluff
 		if (insideBluff && count < minTilesInGroup)
 			outsideBluff = true;
 	}
 
 	// Bluff is reachable
 	return 0;
 }
 
 /**
  * Remove the bluff class and turn it into a plateau.
  */
 function removeBluff(points)
 {
 	for (var i = 0; i < points.length; ++i)
 		addToClass(points[i].x, points[i].z, g_TileClasses.mountain);
 }
 
 /**
  * Create an array of points the fill a bounding box around a terrain feature.
  */
 function createBoundingBox(points, corners)
 {
 	var bb = [];
 	var width = corners.maxX - corners.minX + 1;
 	var length = corners.maxZ - corners.minZ + 1;
 	for (var w = 0; w < width; ++w)
 	{
 		bb[w] = [];
 		for (var l = 0; l < length; ++l)
 		{
 			var curHeight = g_Map.getHeight(w + corners.minX, l + corners.minZ);
 			bb[w][l] = {
 				"height": curHeight,
 				"isFeature": false
 			};
 		}
 	}
 
 	// Define the coordinates that represent the bluff
 	for (var p = 0; p < points.length; ++p)
 	{
 		var pt = points[p];
 		bb[pt.x - corners.minX][pt.z - corners.minZ].isFeature = true;
 	}
 
 	return bb;
 }
 
 /**
  * Flattens the ground touching a terrain feature.
  */
 function fadeToGround(bb, minX, minZ, elevation)
 {
 	var ground = createTerrain(g_Terrains.mainTerrain);
 	for (var x = 0; x < bb.length; ++x)
 		for (var z = 0; z < bb[x].length; ++z)
 		{
 			var pt = bb[x][z];
 			if (!pt.isFeature && nextToFeature(bb, x, z))
 			{
 				var newEl = smoothElevation(x + minX, z + minZ);
 				g_Map.setHeight(x + minX, z + minZ, newEl);
 				ground.place(x + minX, z + minZ);
 			}
 		}
 }
 
 /**
  * Find a 45 degree line in a bounding box that does not intersect any terrain feature.
  */
 function findClearLine(bb, corners, angle, baseHeight)
 {
 	// Angle - 0: northwest; 1: northeast; 2: southeast; 3: southwest
 	var z = corners.maxZ;
 	var xOffset = -1;
 	var zOffset = -1;
 
 	switch(angle)
 	{
 		case 1:
 			xOffset = 1;
 			break;
 		case 2:
 			xOffset = 1;
 			zOffset = 1;
 			z = corners.minZ;
 			break;
 		case 3:
 			zOffset = 1;
 			z = corners.minZ;
 			break;
 	}
 
 	var clearLine = {};
 
 	for (var x = corners.minX; x <= corners.maxX; ++x)
 	{
 		var x2 = x;
 		var z2 = z;
 
 		var clear = true;
 
 		while (x2 >= corners.minX && x2 <= corners.maxX && z2 >= corners.minZ && z2 <= corners.maxZ)
 		{
 			var bp = bb[x2 - corners.minX][z2 - corners.minZ];
 			if (bp.isFeature && g_Map.validT(x2, z2))
 			{
 				clear = false;
 				break;
 			}
 
 			x2 = x2 + xOffset;
 			z2 = z2 + zOffset;
 		}
 
 		if (clear)
 		{
 			var lastX = x2 - xOffset;
 			var lastZ = z2 - zOffset;
 			var midX = Math.floor((x + lastX) / 2);
 			var midZ = Math.floor((z + lastZ) / 2);
 			clearLine = {
 				"x1": x,
 				"z1": z,
 				"x2": lastX,
 				"z2": lastZ,
 				"midX": midX,
 				"midZ": midZ,
 				"height": baseHeight
 			};
 		}
 
 		if (clear && (angle == 1 || angle == 2))
 			break;
 
 		if (!clear && (angle == 0 || angle == 3))
 			break;
 	}
 
 	return clearLine;
 }
 
 /**
  * Returns the corners of a bounding box.
  */
 function findCorners(points)
 {
 	// Find the bounding box of the terrain feature
 	var mapSize = getMapSize();
 	var minX = mapSize + 1;
 	var minZ = mapSize + 1;
 	var maxX = -1;
 	var maxZ = -1;
 
 	for (var p = 0; p < points.length; ++p)
 	{
 		var pt = points[p];
 
 		minX = Math.min(pt.x, minX);
 		minZ = Math.min(pt.z, minZ);
 
 		maxX = Math.max(pt.x, maxX);
 		maxZ = Math.max(pt.z, maxZ);
 	}
 
 	return {
 		"minX": minX,
 		"minZ": minZ,
 		"maxX": maxX,
 		"maxZ": maxZ
 	};
 }
 
 /**
  * Finds the average elevation around a point.
  */
 function smoothElevation(x, z)
 {
 	var min = g_Map.getHeight(x, z);
 
 	for (var xOffset = -1; xOffset <= 1; ++xOffset)
 		for (var zOffset = -1; zOffset <= 1; ++zOffset)
 		{
 			var thisX = x + xOffset;
 			var thisZ = z + zOffset;
 			if (!g_Map.validH(thisX, thisZ))
 				continue;
 
 			var height = g_Map.getHeight(thisX, thisZ);
 			if (height < min)
 				min = height;
 		}
 
 	return min;
 }
 
 /**
  * Determines if a point in a bounding box array is next to a terrain feature.
  */
 function nextToFeature(bb, x, z)
 {
 	for (var xOffset = -1; xOffset <= 1; ++xOffset)
 		for (var zOffset = -1; zOffset <= 1; ++zOffset)
 		{
 			var thisX = x + xOffset;
 			var thisZ = z + zOffset;
 			if (thisX < 0 || thisX >= bb.length || thisZ < 0 || thisZ >= bb[x].length || thisX == 0 && thisZ == 0)
 				continue;
 
 			if (bb[thisX][thisZ].isFeature)
 				return true;
 		}
 
 	return false;
 }
 
 /**
  * Returns a number within a random deviation of a base number.
  */
 function getRandomDeviation(base, deviation)
 {
 	return base + randFloat(-1, 1) * Math.min(base, deviation);
 }
 
 /**
  * Import a given digital elevation model.
  * Scale it to the mapsize and paint the textures specified by coordinate on it.
  *
  * @return the ratio of heightmap tiles per map size tiles
  */
 function paintHeightmap(mapName, func = undefined)
 {
 	/**
 	 * @property heightmap - An array with a square number of heights.
 	 * @property tilemap - The IDs of the palletmap to be painted for each heightmap tile.
 	 * @property pallet - The tile texture names used by the tilemap.
 	 */
 	let mapData = RMS.ReadJSONFile("maps/random/" + mapName + ".hmap");
 
 	let mapSize = getMapSize(); // Width of the map in terrain tiles
 	let hmSize = Math.sqrt(mapData.heightmap.length);
 	let scale = hmSize / (mapSize + 1); // There are mapSize + 1 vertices (each 1 tile is surrounded by 2x2 vertices)
 
 	for (let x = 0; x <= mapSize; ++x)
 		for (let y = 0; y <= mapSize; ++y)
 		{
 			let hmPoint = { "x": x * scale, "y": y * scale };
 			let hmTile = { "x": Math.floor(hmPoint.x), "y": Math.floor(hmPoint.y) };
 			let shift = { "x": 0, "y": 0 };
 
 			if (hmTile.x == 0)
 				shift.x = 1;
 			else if (hmTile.x == hmSize - 1)
 				shift.x = - 2;
 			else if (hmTile.x == hmSize - 2)
 				shift.x = - 1;
 
 			if (hmTile.y == 0)
 				shift.y = 1;
 			else if (hmTile.y == hmSize - 1)
 				shift.y = - 2;
 			else if (hmTile.y == hmSize - 2)
 				shift.y = - 1;
 
 			let neighbors = [];
 			for (let localXi = 0; localXi < 4; ++localXi)
 				for (let localYi = 0; localYi < 4; ++localYi)
 					neighbors.push(mapData.heightmap[(hmTile.x + localXi + shift.x - 1) * hmSize + (hmTile.y + localYi + shift.y - 1)]);
 
 			setHeight(x, y, bicubicInterpolation(hmPoint.x - hmTile.x - shift.x, hmPoint.y - hmTile.y - shift.y, ...neighbors) / scale);
 
 			if (x < mapSize && y < mapSize)
 			{
 				let i = hmTile.x * hmSize + hmTile.y;
 				let tile = mapData.pallet[mapData.tilemap[i]];
 				placeTerrain(x, y, tile);
 
 				if (func)
 					func(tile, x, y);
 			}
 		}
 
 	return scale;
 }
Index: ps/trunk/binaries/data/mods/public/maps/random/neareastern_badlands.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/neareastern_badlands.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/neareastern_badlands.js	(revision 20301)
@@ -1,395 +1,399 @@
 RMS.LoadLibrary("rmgen");
 
 const tCity = "desert_city_tile";
 const tCityPlaza = "desert_city_tile_plaza";
 const tSand = "desert_dirt_rough";
 const tDunes = "desert_sand_dunes_100";
 const tFineSand = "desert_sand_smooth";
 const tCliff = ["desert_cliff_badlands", "desert_cliff_badlands_2"];
 const tForestFloor = "desert_forestfloor_palms";
 const tGrass = "desert_grass_a";
 const tGrassSand25 = "desert_grass_a_stones";
 const tDirt = "desert_dirt_rough";
 const tShore = "desert_shore_stones";
 const tWaterDeep = "desert_shore_stones_wet";
 
 const oBerryBush = "gaia/flora_bush_grapes";
 const oCamel = "gaia/fauna_camel";
 const oFish = "gaia/fauna_fish";
 const oGazelle = "gaia/fauna_gazelle";
 const oGiraffe = "gaia/fauna_giraffe";
 const oGoat = "gaia/fauna_goat";
 const oWildebeest = "gaia/fauna_wildebeest";
 const oStoneLarge = "gaia/geology_stonemine_desert_badlands_quarry";
 const oStoneSmall = "gaia/geology_stone_desert_small";
 const oMetalLarge = "gaia/geology_metal_desert_slabs";
 const oDatePalm = "gaia/flora_tree_date_palm";
 const oSDatePalm = "gaia/flora_tree_senegal_date_palm";
 
 const aBush1 = "actor|props/flora/bush_desert_a.xml";
 const aBush2 = "actor|props/flora/bush_desert_dry_a.xml";
 const aBush3 = "actor|props/flora/bush_dry_a.xml";
 const aBush4 = "actor|props/flora/plant_desert_a.xml";
 const aBushes = [aBush1, aBush2, aBush3, aBush4];
 const aDecorativeRock = "actor|geology/stone_desert_med.xml";
 
 // terrain + entity (for painting)
 const pForest = [tForestFloor + TERRAIN_SEPARATOR + oDatePalm, tForestFloor + TERRAIN_SEPARATOR + oSDatePalm, tForestFloor];
 const pForestOasis = [tGrass + TERRAIN_SEPARATOR + oDatePalm, tGrass + TERRAIN_SEPARATOR + oSDatePalm, tGrass];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 
 var clPlayer = createTileClass();
 var clHill1 = createTileClass();
 var clForest = createTileClass();
 var clPatch = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 
 var [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	// scale radius of player area by map size
 	var radius = scaleByMapSize(15,25);
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 
 	// calculate size based on the radius
 	var size = PI * radius * radius;
 
 	// create the player area
 	var placer = new ClumpPlacer(size, 0.9, 0.5, 10, ix, iz);
 	createArea(placer, paintClass(clPlayer), null);
 
 	// create the city patch
 	var cityRadius = 10;
 	placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tCity, tCityPlaza], [3]);
 	createArea(placer, painter, null);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oBerryBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 		mAngle = randFloat(0, TWO_PI);
 
 	var mDist = 11;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0), new RandomObject(aBushes, 2,4, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2), new RandomObject(aBushes, 2,4, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	var hillSize = PI * radius * radius;
 	// create starting trees
 	var num = floor(hillSize / 100);
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(12, 14);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oDatePalm, num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 }
 RMS.SetProgress(10);
 
 log("Creating dune patches...");
 placer = new ClumpPlacer(scaleByMapSize(40, 150), 0.2, 0.1, 0);
 painter = new TerrainPainter(tDunes);
 createAreas(placer, [painter, paintClass(clPatch)],
 	avoidClasses(clPatch, 2, clPlayer, 0),
 	scaleByMapSize(5, 20)
 );
 RMS.SetProgress(15);
 
 log("Creating sand patches...");
 var placer = new ClumpPlacer(scaleByMapSize(25, 100), 0.2, 0.1, 0);
 var painter = new TerrainPainter([tSand, tFineSand]);
 createAreas(placer, [painter, paintClass(clPatch)],
 	avoidClasses(clPatch, 2, clPlayer, 0),
 	scaleByMapSize(15, 50)
 );
 RMS.SetProgress(20);
 
 log("Creating dirt patches...");
 placer = new ClumpPlacer(scaleByMapSize(25, 100), 0.2, 0.1, 0);
 painter = new TerrainPainter([tDirt]);
 createAreas(placer, [painter, paintClass(clPatch)],
 	avoidClasses(clPatch, 2, clPlayer, 0),
 	scaleByMapSize(15, 50)
 );
 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...");
 var num = round(PI * oRadius / 8);
 var constraint = new AndConstraint([borderClasses(clForest, 0, 3), avoidClasses(clForest, 0)]);
 var halfSize = mapSize/2;
 for (var i = 0; i < num; ++i)
 {
 	var r = 0;
 	var angle = TWO_PI / num * i;
 	do {
 		// Work outward until constraint met
 		var gx = round(halfSize + r * cos(angle));
 		var gz = round(halfSize + r * sin(angle));
 		++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)]);
 num = round(PI * oRadius / 16);
 for (var i = 0; i < num; ++i)
 {
 	var r = 0;
 	var angle = TWO_PI / num * i;
 	do {
 		// Work outward until constraint met
 		var gx = round(halfSize + r * cos(angle));
 		var gz = round(halfSize + r * sin(angle));
 		++r;
 	} while (!constraint.allows(gx,gz) && r < halfSize);
 
 	group = new SimpleGroup(
 		[new SimpleObject(oFish, 1,1, 0,1)],
 		true, clFood, gx, gz
 	);
 	createObjectGroup(group, 0);
 }
 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)
 );
 
 RMS.SetProgress(65);
 
 // calculate desired number of trees for map (based on size)
 const MIN_TREES = 500;
 const MAX_TREES = 2500;
 const P_FOREST = 0.5;
 
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 var numForest = totalTrees * P_FOREST;
 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([tSand, pForest]);
 createAreas(placer, [painter, paintClass(clForest)],
 	avoidClasses(clPlayer, 1, clForest, 10, clHill1, 1),
 	num, 50
 );
 
 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
 );
 
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3), 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
 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4), new RandomObject(aBushes, 2,4, 0,2)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 10, clMetal, 10, clRock, 5, clHill1, 1)],
 	scaleByMapSize(4,16), 100
 );
 
 RMS.SetProgress(80);
 
 log("Creating gazelles...");
 group = new SimpleGroup([new SimpleObject(oGazelle, 5,7, 0,4)], true, clFood);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 5, clHill1, 1, clFood, 10),
 	scaleByMapSize(5,20), 50
 );
 
 log("Creating goats...");
 group = new SimpleGroup([new SimpleObject(oGoat, 2,4, 0,3)], true, clFood);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 5, clHill1, 1, clFood, 10),
 	scaleByMapSize(5,20), 50
 );
 
 log("Creating camels...");
 group = new SimpleGroup([new SimpleObject(oCamel, 2,4, 0,2)], true, clFood);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 5, clHill1, 1, clFood, 10),
 	scaleByMapSize(5,20), 50
 );
 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...");
 group = new SimpleGroup([new RandomObject(aBushes, 2,3, 0,2)]);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clHill1, 1, clPlayer, 0, clForest, 0),
 	scaleByMapSize(16, 262)
 );
 
 log("Creating more decorative rocks...");
 group = new SimpleGroup([new SimpleObject(aDecorativeRock, 1,2, 0,2)]);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clHill1, 1, clPlayer, 0, clForest, 0),
 	scaleByMapSize(16, 262)
 );
 
 setWaterColor(0, 0.227, 0.843);
 setWaterTint(0, 0.545, 0.859);
 setWaterWaviness(1.0);
 setWaterType("clap");
 setWaterMurkiness(0.75);
 setWaterHeight(20);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/oasis.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/oasis.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/oasis.js	(revision 20301)
@@ -1,346 +1,363 @@
 RMS.LoadLibrary("rmgen");
 
 const tSand = ["desert_sand_dunes_100", "desert_dirt_cracks","desert_sand_smooth", "desert_dirt_rough", "desert_dirt_rough_2", "desert_sand_smooth"];
 const tDune = ["desert_sand_dunes_50"];
 const tForestFloor = "desert_forestfloor_palms";
 const tDirt = ["desert_dirt_rough","desert_dirt_rough","desert_dirt_rough", "desert_dirt_rough_2", "desert_dirt_rocks_2"];
 const tRoad = "desert_city_tile";;
 const tRoadWild = "desert_city_tile";;
 const tShoreBlend = "desert_sand_wet";
 const tShore = "dirta";
 const tWater = "desert_sand_wet";
 
 const ePalmShort = "gaia/flora_tree_cretan_date_palm_short";
 const ePalmTall = "gaia/flora_tree_cretan_date_palm_tall";
 const eBush = "gaia/flora_bush_grapes";
 const eCamel = "gaia/fauna_camel";
 const eGazelle = "gaia/fauna_gazelle";
 const eLion = "gaia/fauna_lion";
 const eLioness = "gaia/fauna_lioness";
 const eStoneMine = "gaia/geology_stonemine_desert_quarry";
 const eMetalMine = "gaia/geology_metal_desert_slabs";
 
 const aFlower1 = "actor|props/flora/decals_flowers_daisies.xml";
 const aWaterFlower = "actor|props/flora/water_lillies.xml";
 const aReedsA = "actor|props/flora/reeds_pond_lush_a.xml";
 const aReedsB = "actor|props/flora/reeds_pond_lush_b.xml";
 const aRock = "actor|geology/stone_desert_med.xml";
 const aBushA = "actor|props/flora/bush_desert_dry_a.xml";
 const aBushB = "actor|props/flora/bush_desert_dry_a.xml";
 const aSand = "actor|particle/blowing_sand.xml";
 
 const pForestMain = [tForestFloor + TERRAIN_SEPARATOR + ePalmShort, tForestFloor + TERRAIN_SEPARATOR + ePalmTall, tForestFloor];
 const pOasisForestLight = [tForestFloor + TERRAIN_SEPARATOR + ePalmShort, tForestFloor + TERRAIN_SEPARATOR + ePalmTall, tForestFloor,tForestFloor,tForestFloor
 					,tForestFloor,tForestFloor,tForestFloor,tForestFloor];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clPassage = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 
 initTerrain(tSand);
 
 var [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 var placer = undefined;
 var fx = 0; var fz = 0;
 var ix =0; var iz = 0;
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var elevation = 20;
 
 	// get the x and z in tiles
 	fx = fractionToTiles(playerX[i]);
 	fz = fractionToTiles(playerZ[i]);
 	ix = round(fx);
 	iz = round(fz);
 	addCivicCenterAreaToClass(ix, iz, clPlayer);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tRoadWild, tRoad], [1]);
 	createArea(placer, painter, null);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(eBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = radius*1.3;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(eMetalMine, 1,1, 0,0),new SimpleObject(aBushB, 1,1, 2,2), new SimpleObject(aBushA, 0,2, 1,3),new SimpleObject(ePalmShort, 2,2, 2,3),new SimpleObject(ePalmTall, 1,1, 2,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 	mX = round(fx + mDist*1.5 * cos(mAngle + PI/1.578));
 	mZ = round(fz + mDist*1.5 * sin(mAngle + PI/1.578));
 	group = new SimpleGroup(
 							[new SimpleObject(eMetalMine, 1,1, 0,0),new SimpleObject(aBushB, 1,1, 2,2), new SimpleObject(aBushA, 0,2, 1,3),new SimpleObject(ePalmShort, 2,2, 2,3),new SimpleObject(ePalmTall, 1,1, 2,2)],
 							true, clBaseResource, mX, mZ
 							);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(eStoneMine, 1,1, 0,2),new SimpleObject(aBushB, 1,1, 2,2), new SimpleObject(aBushA, 0,2, 1,3),new SimpleObject(ePalmShort, 2,2, 2,3),new SimpleObject(ePalmTall, 1,1, 2,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 	mX = round(fx + mDist * 1.4 * cos(mAngle - PI /2.46));
 	mZ = round(fz + mDist * 1.4 * sin(mAngle - PI /2.46));
 	group = new SimpleGroup(
 							[new SimpleObject(eStoneMine, 1,1, 0,2),new SimpleObject(aBushB, 1,1, 2,2), new SimpleObject(aBushA, 0,2, 3,3),new SimpleObject(ePalmShort, 2,2, 3,3),new SimpleObject(ePalmTall, 1,1, 3,3)],
 							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)
 						 ,new SimpleObject(aBushB, 1,1, 2,2), new SimpleObject(aBushA, 0,2, 1,3)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 10, clForest, 1, clPlayer, 30, clRock, 10,clBaseResource, 2, clHill, 1),
 	scaleByMapSize(6,25), 100
 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(eMetalMine, 1,1, 0,0),new SimpleObject(ePalmShort, 1,2, 2,3),new SimpleObject(ePalmTall, 0,1, 2,2)
 						 ,new SimpleObject(aBushB, 1,1, 2,2), new SimpleObject(aBushA, 0,2, 1,3)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 10, clForest, 1, clPlayer, 30, clMetal, 10,clBaseResource, 2, clRock, 10, clHill, 1),
 	scaleByMapSize(6,25), 100
 );
 RMS.SetProgress(65);
 
 log("Creating small decorative rocks...");
 group = new SimpleGroup( [new SimpleObject(aRock, 2,4, 0,2)], true, undefined );
 createObjectGroupsDeprecated(group, 0, avoidClasses(clWater, 3, clForest, 0, clPlayer, 10, clHill, 1, clFood, 20), 30, scaleByMapSize(10,50) );
 
 RMS.SetProgress(70);
 
 log("Creating Camels...");
 group = new SimpleGroup(
 	[new SimpleObject(eCamel, 1,2, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 0, clPlayer, 10, clHill, 1, clFood, 20),
 	1 * numPlayers, 50
 );
 RMS.SetProgress(75);
 
 log("Creating Gazelles...");
 group = new SimpleGroup(
 	[new SimpleObject(eGazelle, 2,4, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 0, clPlayer, 10, clHill, 1, clFood, 20),
 	1 * numPlayers, 50
 );
 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));
 	var animY = round(fz + aDist * sin(aAngle));
 	group = new RandomGroup(
 		[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)]
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 2, clHill, 1, clPlayer, 1, clPassage, 1),
 	scaleByMapSize(10, 40), 20
 );
 log ("Creating Sand blows and beautifications");
 for (var sandx = 0; sandx < mapSize; sandx += 4)
 	for (var sandz = 0; sandz < mapSize; sandz += 4)
 	{
 		if (getHeight(sandx,sandz) > 3.4)
 		{
 			if (randBool((getHeight(sandx,sandz) - 3.4) / 1.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))
 			{
 				group = new SimpleGroup( [new SimpleObject(aWaterFlower, 1,4, 1,2)], true, undefined, sandx,sandz );
 				createObjectGroup(group, 0);
 			}
 			else if (randBool(0.7) && getHeight(sandx,sandz) < -1.9)
 			{
 				group = new SimpleGroup( [new SimpleObject(aReedsA, 5,12, 0,2),new SimpleObject(aReedsB, 5,12, 0,2)], true, undefined, sandx,sandz );
 				createObjectGroup(group, 0);
 			}
 
 			if (getTileClass(clPassage).countInRadius(sandx,sandz,2,true) > 0) {
 				if (randBool(0.4))
 				{
 					group = new SimpleGroup( [new SimpleObject(aWaterFlower, 1,4, 1,2)], true, undefined, sandx,sandz );
 					createObjectGroup(group, 0);
 				}
 				else if (randBool(0.7) && getHeight(sandx,sandz) < -1.9)
 				{
 					group = new SimpleGroup( [new SimpleObject(aReedsA, 5,12, 0,2),new SimpleObject(aReedsB, 5,12, 0,2)], true, undefined, sandx,sandz );
 					createObjectGroup(group, 0);
 				}
 			}
 		}
 	}
 
 setSkySet("sunny");
 setSunColor(0.914,0.827,0.639);
 setSunRotation(PI/3);
 setSunElevation(0.5);
 setWaterColor(0, 0.227, 0.843);
 setWaterTint(0, 0.545, 0.859);
 setWaterWaviness(1.0);
 setWaterType("clap");
 setWaterMurkiness(0.5);
 setTerrainAmbientColor(0.45, 0.5, 0.6);
 setUnitsAmbientColor(0.501961, 0.501961, 0.501961);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/phoenician_levant.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/phoenician_levant.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/phoenician_levant.js	(revision 20301)
@@ -1,411 +1,386 @@
 RMS.LoadLibrary("rmgen");
 
 //TILE_CENTERED_HEIGHT_MAP = true;
 
 const tCity = "medit_city_pavement";
 const tCityPlaza = "medit_city_pavement";
 const tHill = ["medit_dirt", "medit_dirt_b", "medit_dirt_c", "medit_rocks_grass", "medit_rocks_grass"];
 const tMainDirt = "medit_dirt";
 const tCliff = "medit_cliff_aegean";
 const tForestFloor = "medit_rocks_shrubs";
 const tGrass = "medit_rocks_grass";
 const tRocksShrubs = "medit_rocks_shrubs";
 const tRocksGrass = "medit_rocks_grass";
 const tDirt = "medit_dirt_b";
 const tDirtB = "medit_dirt_c";
 const tShore = "medit_sand";
 const tWater = "medit_sand_wet";
 
 const oGrapeBush = "gaia/flora_bush_grapes";
 const oDeer = "gaia/fauna_deer";
 const oFish = "gaia/fauna_fish";
 const oSheep = "gaia/fauna_sheep";
 const oGoat = "gaia/fauna_goat";
 const oStoneLarge = "gaia/geology_stonemine_medit_quarry";
 const oStoneSmall = "gaia/geology_stone_mediterranean";
 const oMetalLarge = "gaia/geology_metal_mediterranean_slabs";
 const oDatePalm = "gaia/flora_tree_cretan_date_palm_short";
 const oSDatePalm = "gaia/flora_tree_cretan_date_palm_tall";
 const oCarob = "gaia/flora_tree_carob";
 const oFanPalm = "gaia/flora_tree_medit_fan_palm";
 const oPoplar = "gaia/flora_tree_poplar_lombardy";
 const oCypress = "gaia/flora_tree_cypress";
 
 const aBush1 = "actor|props/flora/bush_medit_sm.xml";
 const aBush2 = "actor|props/flora/bush_medit_me.xml";
 const aBush3 = "actor|props/flora/bush_medit_la.xml";
 const aBush4 = "actor|props/flora/bush_medit_me.xml";
 const aDecorativeRock = "actor|geology/stone_granite_med.xml";
 
 // terrain + entity (for painting)
 const pForest = [tForestFloor + TERRAIN_SEPARATOR + oDatePalm, tForestFloor + TERRAIN_SEPARATOR + oSDatePalm, tForestFloor + TERRAIN_SEPARATOR + oCarob, tForestFloor, tForestFloor];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 
 var clPlayer = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clGrass = createTileClass();
 var clHill = createTileClass();
 var clIsland = createTileClass();
 
 var playerIDs = sortAllPlayers();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(0.66 + 0.2 * (i % 2));
 	var fz = fractionToTiles((i + 1) / (numPlayers + 1));
 	var ix = floor(fx);
 	var iz = floor(fz);
 	addCivicCenterAreaToClass(ix, iz, clPlayer);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	var placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tCityPlaza, tCity], [1]);
 	createArea(placer, painter, null);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oGrapeBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var num = 2;
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(11, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oCarob, num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aBush1, clBaseResource, radius);
 }
 
 RMS.SetProgress(30);
 
 paintRiver({
 	"horizontal": false,
 	"parallel": true,
 	"position": 0,
 	"width": 1,
 	"fadeDist": 0.05,
 	"deviation": 0,
 	"waterHeight": -3,
 	"landHeight": 1,
 	"meanderShort": 20,
 	"meanderLong": 0,
 	"waterFunc": (ix, iz, height) => {
 
 		if (height < 0)
 			addToClass(ix, iz, clWater);
 
 		if (height < -1.5)
 			placeTerrain(ix, iz, tWater);
 		else
 			placeTerrain(ix, iz, tShore);
 	}
 });
 
 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;
 const MAX_TREES = 2500;
 const P_FOREST = 0.5;
 
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 var numForest = totalTrees * P_FOREST;
 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
 );
 
 log("Creating cyprus small stone mines...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	stayClasses(clIsland, 9),
 	14 * scaleByMapSize(4,16), 100
 );
 
 log("Creating cyprus metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	stayClasses(clIsland, 9),
 	14 * scaleByMapSize(4,16), 100
 );
 
 log("Creating stone mines...");
 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, 3, clHill, 1),
 	scaleByMapSize(4,16), 100
 );
 
 log("Creating small stone quarries...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 1, clPlayer, 20, clRock, 10, clWater, 3, clHill, 1),
 	scaleByMapSize(4,16), 100
 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clWater, 3, clHill, 1),
 	scaleByMapSize(4,16), 100
 );
 
 RMS.SetProgress(65);
 
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aDecorativeRock, 1,3, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clWater, 1, clForest, 0, clPlayer, 0, clHill, 1),
 	scaleByMapSize(16, 262), 50
 );
 
 log("Creating shrubs...");
 group = new SimpleGroup(
 	[new SimpleObject(aBush2, 1,2, 0,1), new SimpleObject(aBush1, 1,3, 0,2), new SimpleObject(aBush4, 1,2, 0,1), new SimpleObject(aBush3, 1,3, 0,2)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clWater, 3, clPlayer, 0, clHill, 1),
 	scaleByMapSize(40, 360), 50
 );
 RMS.SetProgress(70);
 
 log("Creating fish...");
 group = new SimpleGroup([new SimpleObject(oFish, 1,3, 2,6)], true, clFood);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clIsland, 2, clFood, 10), stayClasses(clWater, 5)],
 	3*scaleByMapSize(5,20), 50
 );
 
 log("Creating sheeps...");
 group = new SimpleGroup([new SimpleObject(oSheep, 5,7, 0,4)], true, clFood);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 7, clWater, 3, clFood, 10, clHill, 1),
 	scaleByMapSize(5,20), 50
 );
 
 log("Creating goats...");
 group = new SimpleGroup([new SimpleObject(oGoat, 2,4, 0,3)], true, clFood);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 7, clWater, 3, clFood, 10, clHill, 1),
 	scaleByMapSize(5,20), 50
 );
 
 log("Creating deers...");
 group = new SimpleGroup([new SimpleObject(oDeer, 2,4, 0,2)], true, clFood);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 7, clWater, 3, clFood, 10, clHill, 1),
 	scaleByMapSize(5,20), 50
 );
 
 log("Creating grape bushes...");
 group = new SimpleGroup(
 	[new SimpleObject(oGrapeBush, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 0, clPlayer, 15, clHill, 1, clFood, 7),
 	randIntInclusive(1, 4) * numPlayers + 2, 50
 );
 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");
 setSunColor(0.917, 0.828, 0.734);
 setWaterColor(0.263,0.314,0.631);
 setWaterTint(0.133, 0.725,0.855);
 setWaterWaviness(2.0);
 setWaterType("ocean");
 setWaterMurkiness(0.8);
 
 setTerrainAmbientColor(0.57, 0.58, 0.55);
 setUnitsAmbientColor(0.447059, 0.509804, 0.54902);
 
 setSunElevation(0.671884);
 setSunRotation(-0.582913);
 
 setFogFactor(0.2);
 setFogThickness(0.15);
 setFogColor(0.8, 0.7, 0.6);
 
 setPPEffect("hdr");
 setPPContrast(0.53);
 setPPSaturation(0.47);
 setPPBloom(0.52);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/rhine_marshlands.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/rhine_marshlands.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/rhine_marshlands.js	(revision 20301)
@@ -1,396 +1,370 @@
 RMS.LoadLibrary("rmgen");
 
 const tGrass = ["temp_grass", "temp_grass", "temp_grass_d"];
 const tForestFloor = "temp_plants_bog";
 const tGrassA = "temp_grass_plants";
 const tGrassB = "temp_plants_bog";
 const tMud = "temp_mud_a";
 const tRoad = "temp_road";
 const tRoadWild = "temp_road_overgrown";
 const tShoreBlend = "temp_grass_plants";
 const tShore = "temp_plants_bog";
 const tWater = "temp_mud_a";
 
 const oBeech = "gaia/flora_tree_euro_beech";
 const oOak = "gaia/flora_tree_oak";
 const oBerryBush = "gaia/flora_bush_berry";
 const oDeer = "gaia/fauna_deer";
 const oHorse = "gaia/fauna_horse";
 const oWolf = "gaia/fauna_wolf";
 const oRabbit = "gaia/fauna_rabbit";
 const oStoneLarge = "gaia/geology_stonemine_temperate_quarry";
 const oStoneSmall = "gaia/geology_stone_temperate";
 const oMetalLarge = "gaia/geology_metal_temperate_slabs";
 
 const aGrass = "actor|props/flora/grass_soft_small_tall.xml";
 const aGrassShort = "actor|props/flora/grass_soft_large.xml";
 const aRockLarge = "actor|geology/stone_granite_med.xml";
 const aRockMedium = "actor|geology/stone_granite_med.xml";
 const aReeds = "actor|props/flora/reeds_pond_lush_a.xml";
 const aLillies = "actor|props/flora/water_lillies.xml";
 const aBushMedium = "actor|props/flora/bush_medit_me.xml";
 const aBushSmall = "actor|props/flora/bush_medit_sm.xml";
 
 const pForestD = [tForestFloor + TERRAIN_SEPARATOR + oBeech, tForestFloor];
 const pForestP = [tForestFloor + TERRAIN_SEPARATOR + oOak, tForestFloor];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 
 var [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 	addCivicCenterAreaToClass(ix, iz, clPlayer);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	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);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oBerryBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = radius - 4;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 	var hillSize = PI * radius * radius;
 	// create starting trees
 	var num = floor(hillSize / 100);
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = 12;
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oBeech, num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 
 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;
 const MAX_TREES = 2500;
 const P_FOREST = 0.7;
 
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 var numForest = totalTrees * P_FOREST;
 var numStragglers = totalTrees * (1.0 - P_FOREST);
 
 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
 );
 
 log("Creating small stone quarries...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clWater, 0, clForest, 1, clPlayer, 20, clRock, 10, clHill, 1)],
 	scaleByMapSize(4,16), 100
 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clWater, 0, clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 1)],
 	scaleByMapSize(4,16), 100
 );
 
 RMS.SetProgress(60);
 
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockMedium, 1,3, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0),
 	scaleByMapSize(16, 262), 50
 );
 
 RMS.SetProgress(65);
 
 log("Creating large decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0),
 	scaleByMapSize(8, 131), 50
 );
 
 RMS.SetProgress(70);
 
 log("Creating deer...");
 group = new SimpleGroup(
 	[new SimpleObject(oDeer, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 0, clForest, 0, clPlayer, 20, clHill, 1, clFood, 13),
 	6 * numPlayers, 50
 );
 
 log("Creating horse...");
 group = new SimpleGroup(
 	[new SimpleObject(oHorse, 1,3, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 0, clForest, 0, clPlayer, 20, clHill, 1, clFood, 13),
 	3 * numPlayers, 50
 );
 
 RMS.SetProgress(75);
 
 log("Creating rabbit...");
 group = new SimpleGroup(
 	[new SimpleObject(oRabbit, 5,7, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 0, clForest, 0, clPlayer, 20, clHill, 1, clFood, 13),
 	6 * numPlayers, 50
 );
 
 log("Creating wolf...");
 group = new SimpleGroup(
 	[new SimpleObject(oWolf, 1,3, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 0, clForest, 0, clPlayer, 20, clHill, 1, clFood, 13),
 	3 * numPlayers, 50
 );
 
 log("Creating berry bush...");
 group = new SimpleGroup(
 	[new SimpleObject(oBerryBush, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 10),
 	randIntInclusive(1, 4) * numPlayers + 2, 50
 );
 
 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
 setWaterTint(0.161,0.514,0.635);				// clear blue for blueness
 setWaterMurkiness(0.8);
 setWaterWaviness(1.0);
 setWaterType("clap");
 
 setFogThickness(0.25);
 setFogFactor(0.6);
 
 setPPEffect("hdr");
 setPPSaturation(0.44);
 setPPBloom(0.3);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/rmbiome/randombiome.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/rmbiome/randombiome.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/rmbiome/randombiome.js	(revision 20301)
@@ -1,76 +1,76 @@
 RMS.LoadLibrary("rmbiome/biomes");
 
 var g_BiomeID;
 
 var g_Terrains = {};
 var g_Gaia = {};
 var g_Decoratives = {};
 var g_TreeCount = {};
 
 function currentBiome()
 {
 	return g_BiomeID;
 }
 
 function setSelectedBiome()
 {
-	setBiome(g_MapSettings.Biome);
+	setBiome(g_MapSettings.Biome || "alpine");
 }
 
 function setBiome(biomeID)
 {
 	loadBiomeFile("defaultbiome");
 
 	setSkySet(pickRandom(["cirrus", "cumulus", "sunny"]));
 	setSunRotation(randFloat(0, TWO_PI));
 	setSunElevation(randFloat(PI/ 6, PI / 3));
 
 	g_BiomeID = biomeID;
 
 	loadBiomeFile("biomes/" + biomeID);
 
 	let setupBiomeFunc = global["setupBiome_" + biomeID];
 	if (setupBiomeFunc)
 		setupBiomeFunc();
 }
 
 function loadBiomeFile(file)
 {
 	let path = "maps/random/rmbiome/" + file + ".json";
 
 	if (!RMS.FileExists(path))
 	{
 		error("Could not load biome file '" + file + "'");
 		return;
 	}
 
 	let biome = RMS.ReadJSONFile(path)
 
 	let copyProperties = (from, to) => {
 		for (let prop in from)
 		{
 			if (typeof from[prop] == "object" && !Array.isArray(from[prop]))
 			{
 				if (!to[prop])
 					to[prop] = {};
 
 				copyProperties(from[prop], to[prop]);
 			}
 			else
 				to[prop] = from[prop];
 		}
 	};
 
 	for (let rmsGlobal in biome)
 		if (rmsGlobal != "Description")
 			copyProperties(biome[rmsGlobal], global["g_" + rmsGlobal]);
 }
 
 function rBiomeTreeCount(multiplier = 1)
 {
 	return [
 		g_TreeCount.minTrees * multiplier,
 		g_TreeCount.maxTrees * multiplier,
 		g_TreeCount.forestProbability
 	];
 }
Index: ps/trunk/binaries/data/mods/public/maps/random/alpine_lakes.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/alpine_lakes.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/alpine_lakes.js	(revision 20301)
@@ -1,356 +1,354 @@
 RMS.LoadLibrary("rmgen");
 
 // late spring
 if (randBool())
 {
 	setFogThickness(0.26);
 	setFogFactor(0.4);
 
 	setPPEffect("hdr");
 	setPPSaturation(0.48);
 	setPPContrast(0.53);
 	setPPBloom(0.12);
 
 	var tPrimary = ["alpine_dirt_grass_50"];
 	var tForestFloor = "alpine_forrestfloor";
 	var tCliff = ["alpine_cliff_a", "alpine_cliff_b", "alpine_cliff_c"];
 	var tSecondary = "alpine_grass_rocky";
 	var tHalfSnow = ["alpine_grass_snow_50", "alpine_dirt_snow"];
 	var tSnowLimited = ["alpine_snow_rocky"];
 	var tDirt = "alpine_dirt";
 	var tRoad = "new_alpine_citytile";
 	var tRoadWild = "new_alpine_citytile";
 	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";
 	var oFish = "gaia/fauna_fish";
 	var oRabbit = "gaia/fauna_rabbit";
 	var oStoneLarge = "gaia/geology_stonemine_alpine_quarry";
 	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";
 	var aRockMedium = "actor|geology/stone_granite_med.xml";
 	var aBushMedium = "actor|props/flora/bush_medit_me.xml";
 	var aBushSmall = "actor|props/flora/bush_medit_sm.xml";
 }
 else
 //winter
 {
 	setFogFactor(0.35);
 	setFogThickness(0.19);
 	setPPSaturation(0.37);
 	setPPEffect("hdr");
 
 	var tPrimary = ["alpine_snow_a", "alpine_snow_b"];
 	var tForestFloor = "alpine_forrestfloor_snow";
 	var tCliff = ["alpine_cliff_snow"];
 	var tSecondary = "alpine_grass_snow_50";
 	var tHalfSnow = ["alpine_grass_snow_50", "alpine_dirt_snow"];
 	var tSnowLimited = ["alpine_snow_a", "alpine_snow_b"];
 	var tDirt = "alpine_dirt";
 	var tRoad = "new_alpine_citytile";
 	var tRoadWild = "new_alpine_citytile";
 	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";
 	var oFish = "gaia/fauna_fish";
 	var oRabbit = "gaia/fauna_rabbit";
 	var oStoneLarge = "gaia/geology_stonemine_alpine_quarry";
 	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";
 	var aRockMedium = "actor|geology/stone_granite_med.xml";
 	var aBushMedium = "actor|props/flora/bush_medit_me_dry.xml";
 	var aBushSmall = "actor|props/flora/bush_medit_sm_dry.xml";
 }
 
 //other constants
 const pForest = [tForestFloor + TERRAIN_SEPARATOR + oPine, tForestFloor];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 
 initTerrain(tPrimary);
 
 var [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 	addCivicCenterAreaToClass(ix, iz, clPlayer);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	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);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oBerryBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 		mAngle = randFloat(0, TWO_PI);
 
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 	var hillSize = PI * radius * radius;
 	// create starting trees
 	var num = floor(hillSize / 100);
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(11, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oPine, num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 
 RMS.SetProgress(20);
 
 log("Creating hills...");
 createMountains(tCliff, avoidClasses(clPlayer, 20, clHill, 8), clHill, scaleByMapSize(10, 40) * numPlayers, floor(scaleByMapSize(40, 60)), floor(scaleByMapSize(4, 5)), floor(scaleByMapSize(7, 15)), floor(scaleByMapSize(5, 15)));
 
 RMS.SetProgress(30);
 
 var lakeAreas = [];
 var playerConstraint = new AvoidTileClassConstraint(clPlayer, 20);
 var waterConstraint = new AvoidTileClassConstraint(clWater, 8);
 
 for (var x = 0; x < mapSize; ++x)
 	for (var z = 0; z < mapSize; ++z)
 		if (playerConstraint.allows(x, z) && waterConstraint.allows(x, z))
 			lakeAreas.push([x, z]);
 
 var lakeAreaLen;
 
 log("Creating lakes...");
 
 var numLakes = scaleByMapSize(5, 16);
 for (var i = 0; i < numLakes; ++i)
 {
 	lakeAreaLen = lakeAreas.length;
 	if (!lakeAreaLen)
 		break;
 
 	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
 	);
 
 	if (newLake && newLake.length)
 	{
 		var n = 0;
 		for (var j = 0; j < lakeAreaLen; ++j)
 		{
 			var x = lakeAreas[j][0], z = lakeAreas[j][1];
 			if (playerConstraint.allows(x, z) && waterConstraint.allows(x, z))
 				lakeAreas[n++] = lakeAreas[j];
 		}
 		lakeAreas.length = n;
 	}
 
 }
 paintTerrainBasedOnHeight(3, floor(scaleByMapSize(20, 40)), 0, tCliff);
 paintTerrainBasedOnHeight(floor(scaleByMapSize(20, 40)), 100, 3, tSnowLimited);
 
 createBumps(avoidClasses(clWater, 2, clPlayer, 20));
 
 createForests(
  [tPrimary, tForestFloor, tForestFloor, pForest, pForest],
  avoidClasses(clPlayer, 20, clForest, 17, clHill, 0, clWater, 2),
  clForest,
  1.0
 );
 
 RMS.SetProgress(60);
 
 log("Creating dirt patches...");
 createLayeredPatches(
  [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
  [[tDirt,tHalfSnow], [tHalfSnow,tSnowLimited]],
  [2],
  avoidClasses(clWater, 3, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12)
 );
 
 log("Creating grass patches...");
 createPatches(
  [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
  tSecondary,
  avoidClasses(clWater, 3, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12)
 );
 
 RMS.SetProgress(65);
 
 log("Creating stone mines...");
 createMines(
  [
   [new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)],
   [new SimpleObject(oStoneSmall, 2,5, 1,3)]
  ],
  avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clRock, 10, clHill, 1)
 );
 
 log("Creating metal mines...");
 createMines(
  [
   [new SimpleObject(oMetalLarge, 1,1, 0,4)]
  ],
  avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 1),
  clMetal
 );
 
 RMS.SetProgress(70);
 
 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),
   scaleByMapSize(13, 200),
   scaleByMapSize(13, 200),
   scaleByMapSize(13, 200)
  ],
  avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0)
 );
 
 RMS.SetProgress(75);
 
 createFood
 (
  [
   [new SimpleObject(oDeer, 5,7, 0,4)],
   [new SimpleObject(oRabbit, 2,3, 0,2)]
  ],
  [
   3 * numPlayers,
   3 * numPlayers
  ],
  avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 20)
 );
 
 createFood
 (
  [
   [new SimpleObject(oBerryBush, 5,7, 0,4)]
  ],
  [
   randIntInclusive(1, 4) * numPlayers + 2
  ],
  avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 10)
 );
 
 createFood
 (
  [
   [new SimpleObject(oFish, 2,3, 0,2)]
  ],
  [
   15 * numPlayers
  ],
  [avoidClasses(clFood, 20), stayClasses(clWater, 6)]
 );
 
 RMS.SetProgress(85);
 
 var types = [oPine];
 createStragglerTrees(types, avoidClasses(clWater, 5, clForest, 3, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6));
 
 setSkySet(pickRandom(["cirrus", "cumulus", "sunny"]));
 setSunRotation(randFloat(0, TWO_PI));
 setSunElevation(randFloat(PI/ 5, PI / 3));
 setWaterColor(0.0, 0.047, 0.286);				// dark majestic blue
 setWaterTint(0.471, 0.776, 0.863);				// light blue
 setWaterMurkiness(0.82);
 setWaterWaviness(3.0);
 setWaterType("clap");
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/alpine_valley.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/alpine_valley.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/alpine_valley.js	(revision 20301)
@@ -1,597 +1,556 @@
 RMS.LoadLibrary("rmgen");
 
 TILE_CENTERED_HEIGHT_MAP = true;
 
 // late spring
 if (randBool())
 {
 	var tPrimary = ["alpine_dirt_grass_50"];
 	var tForestFloor = "alpine_forrestfloor";
 	var tCliff = ["alpine_cliff_a", "alpine_cliff_b", "alpine_cliff_c"];
 	var tSecondary = "alpine_grass_rocky";
 	var tHalfSnow = ["alpine_grass_snow_50", "alpine_dirt_snow"];
 	var tSnowLimited = ["alpine_snow_rocky"];
 	var tDirt = "alpine_dirt";
 	var tRoad = "new_alpine_citytile";
 	var tRoadWild = "new_alpine_citytile";
 
 	var oPine = "gaia/flora_tree_pine";
 	var oBerryBush = "gaia/flora_bush_berry";
 	var oDeer = "gaia/fauna_deer";
 	var oRabbit = "gaia/fauna_rabbit";
 	var oStoneLarge = "gaia/geology_stonemine_alpine_quarry";
 	var oStoneSmall = "gaia/geology_stone_alpine_a";
 	var oMetalLarge = "gaia/geology_metal_alpine_slabs";
 
 	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";
 	var aRockMedium = "actor|geology/stone_granite_med.xml";
 	var aBushMedium = "actor|props/flora/bush_medit_me.xml";
 	var aBushSmall = "actor|props/flora/bush_medit_sm.xml";
 }
 else
 //winter
 {
 	var tPrimary = ["alpine_snow_a", "alpine_snow_b"];
 	var tForestFloor = "alpine_forrestfloor_snow";
 	var tCliff = ["alpine_cliff_snow"];
 	var tSecondary = "alpine_grass_snow_50";
 	var tHalfSnow = ["alpine_grass_snow_50", "alpine_dirt_snow"];
 	var tSnowLimited = ["alpine_snow_a", "alpine_snow_b"];
 	var tDirt = "alpine_dirt";
 	var tRoad = "new_alpine_citytile";
 	var tRoadWild = "new_alpine_citytile";
 
 	var oPine = "gaia/flora_tree_pine_w";
 	var oBerryBush = "gaia/flora_bush_berry";
 	var oDeer = "gaia/fauna_deer";
 	var oRabbit = "gaia/fauna_rabbit";
 	var oStoneLarge = "gaia/geology_stonemine_alpine_quarry";
 	var oStoneSmall = "gaia/geology_stone_alpine_a";
 	var oMetalLarge = "gaia/geology_metal_alpine_slabs";
 
 	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";
 	var aRockMedium = "actor|geology/stone_granite_med.xml";
 	var aBushMedium = "actor|props/flora/bush_medit_me_dry.xml";
 	var aBushSmall = "actor|props/flora/bush_medit_sm_dry.xml";
 }
 
 const pForest = [tForestFloor + TERRAIN_SEPARATOR + oPine, tForestFloor];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 const mapArea = mapSize*mapSize;
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 
 initTerrain(tPrimary);
 
 var [playerIDs, playerX, playerZ, playerAngle, startAngle] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	ix = round(fx);
 	iz = round(fz);
 	addCivicCenterAreaToClass(ix, iz, clPlayer);
 
 	// 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);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oBerryBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 		mAngle = randFloat(0, TWO_PI);
 
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 	var hillSize = PI * radius * radius;
 	// create starting trees
 	var num = floor(hillSize / 100);
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(11, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oPine, num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 RMS.SetProgress(20);
 
 //place the mountains
 var points = [];
 
 var edgesConncetedToPoints = [];
 
 //we want the points near the start locations be the first ones. hence we use two "for" blocks
 for (var i = 0; i < numPlayers; ++i)
 {
 	playerAngle[i] = startAngle + (i+0.5)*TWO_PI/numPlayers;
 	points.push([round(fractionToTiles(0.5 + 0.49 * cos(playerAngle[i]))), round(fractionToTiles(0.5 + 0.49 * sin(playerAngle[i])))]);
 }
 
 //the order of the other points doesn't matter
 for (var i = 0; i < numPlayers; ++i)
 {
 	playerAngle[i] = startAngle + (i+0.7)*TWO_PI/numPlayers;
 	points.push([round(fractionToTiles(0.5 + 0.34 * cos(playerAngle[i]))), round(fractionToTiles(0.5 + 0.34 * sin(playerAngle[i])))]);
 	playerAngle[i] = startAngle + (i+0.3)*TWO_PI/numPlayers;
 	points.push([round(fractionToTiles(0.5 + 0.34 * cos(playerAngle[i]))), round(fractionToTiles(0.5 + 0.34 * sin(playerAngle[i])))]);
 	playerAngle[i] = startAngle + (i+0.5)*TWO_PI/numPlayers;
 	points.push([round(fractionToTiles(0.5 + 0.18 * cos(playerAngle[i]))), round(fractionToTiles(0.5 + 0.18 * sin(playerAngle[i])))]);
 }
 
 //add the center of the map
 points.push([round(fractionToTiles(0.5)), round(fractionToTiles(0.5))]);
 
 var numPoints = numPlayers * 4 + 1;
 
 for (var i = 0; i < numPoints; ++i)
 	edgesConncetedToPoints.push(0);
 
 //we are making a planar graph where every edge is a straight line.
 var possibleEdges = [];
 
 //add all of the possible combinations
 for (var i = 0; i < numPoints; ++i)
 	for (var j = numPlayers; j < numPoints; ++j)
 		if (j > i)
 			possibleEdges.push([i,j]);
 
 //we need a matrix so that we can prevent the mountain ranges from bocking a player
 var matrix = [];
 for (var i = 0; i < numPoints; ++i)
 {
 	matrix.push([]);
 	for (var j = 0; j < numPoints; ++j)
 		matrix[i].push(i < numPlayers && j < numPlayers && i != j && (i == j - 1 || i == j + 1))
 }
 
 //find and place the edges
 while (possibleEdges.length)
 {
 	var index = randIntExclusive(0, possibleEdges.length);
 
 	//ensure that a point is connected to a maximum of 3 others
 	if (edgesConncetedToPoints[possibleEdges[index][0]] > 2 || edgesConncetedToPoints[possibleEdges[index][1]] > 2)
 	{
 		possibleEdges.splice(index,1);
 		continue;
 	}
 
 	//we don't want ranges that are longer than half of the map's size
 	if ((((points[possibleEdges[index][0]][0] - points[possibleEdges[index][1]][0]) *
 		(points[possibleEdges[index][0]][0] - points[possibleEdges[index][1]][0])) +
 		((points[possibleEdges[index][0]][1] - points[possibleEdges[index][1]][1]) *
 		(points[possibleEdges[index][0]][1] - points[possibleEdges[index][1]][1]))) >
 		mapArea)
 	{
 		possibleEdges.splice(index,1);
 		continue;
 	}
 
 	//dfs
 	var q = [possibleEdges[index][0]];
 
 	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);
 			backtree.push(-1);
 		}
 
 		for (var i = 0; i < numPoints; ++i)
 			if (matrix[selected][i])
 			{
 				if (i == backtree[tree.lastIndexOf(selected)])
 					continue;
 
 				if (tree.indexOf(i) == -1)
 				{
 					tree.push(i);
 					backtree.push(selected);
 					q.unshift(i);
 				}
 				else
 				{
 					accept = false;
 					matrix[possibleEdges[index][0]][possibleEdges[index][1]] = false;
 					matrix[possibleEdges[index][1]][possibleEdges[index][0]] = false;
 					break;
 				}
 			}
 	}
 
 	if (!accept)
 	{
 		possibleEdges.splice(index,1);
 		continue;
 	}
 
 	var ix = points[possibleEdges[index][0]][0];
 	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)
 	{
 		matrix[possibleEdges[index][0]][possibleEdges[index][1]] = false;
 		matrix[possibleEdges[index][1]][possibleEdges[index][0]] = false;
 		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)
 	{
 		if (possibleEdges[index][0] != possibleEdges[i][0] && possibleEdges[index][1] != possibleEdges[i][0] &&
 			possibleEdges[index][0] != possibleEdges[i][1] && possibleEdges[index][1] != possibleEdges[i][1])
 		{
 
 			if (checkIfIntersect (points[possibleEdges[index][0]][0], points[possibleEdges[index][0]][1],
 				points[possibleEdges[index][1]][0], points[possibleEdges[index][1]][1], points[possibleEdges[i][0]][0],
 				points[possibleEdges[i][0]][1], points[possibleEdges[i][1]][0], points[possibleEdges[i][1]][1], scaleByMapSize(9,15) + scaleByMapSize(10,15)))
 			{
 				possibleEdges.splice(i,1);
 				--i;
 				if (index > i)
 					--index;
 			}
 		}
 		else if (((possibleEdges[index][0] == possibleEdges[i][0] && possibleEdges[index][1] != possibleEdges[i][1]) ||
 			(possibleEdges[index][1] == possibleEdges[i][0] && possibleEdges[index][0] != possibleEdges[i][1])) &&
 			distanceOfPointFromLine(points[possibleEdges[index][0]][0],points[possibleEdges[index][0]][1],
 			points[possibleEdges[index][1]][0], points[possibleEdges[index][1]][1],points[possibleEdges[i][1]][0], points[possibleEdges[i][1]][1])
 			< scaleByMapSize(9,15) + scaleByMapSize(10,15))
 		{
 			possibleEdges.splice(i,1);
 			--i;
 			if (index > i)
 				--index;
 		}
 		else if (((possibleEdges[index][0] == possibleEdges[i][1] && possibleEdges[index][1] != possibleEdges[i][0]) ||
 			(possibleEdges[index][1] == possibleEdges[i][1] && possibleEdges[index][0] != possibleEdges[i][0])) &&
 			distanceOfPointFromLine(points[possibleEdges[index][0]][0],points[possibleEdges[index][0]][1],
 			points[possibleEdges[index][1]][0], points[possibleEdges[index][1]][1],points[possibleEdges[i][0]][0], points[possibleEdges[i][0]][1])
 			< scaleByMapSize(9,15) + scaleByMapSize(10,15))
 		{
 			possibleEdges.splice(i,1);
 			--i;
 			if (index > i)
 				--index;
 		}
 
 	}
 
 	edgesConncetedToPoints[possibleEdges[index][0]] += 1;
 	edgesConncetedToPoints[possibleEdges[index][1]] += 1;
 
 	possibleEdges.splice(index,1);
 }
 
 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
 );
 RMS.SetProgress(50);
 
 // calculate desired number of trees for map (based on size)
 var MIN_TREES = 500;
 var MAX_TREES = 3000;
 var P_FOREST = 0.7;
 
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 var numForest = totalTrees * P_FOREST;
 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...");
 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, clHill, 1),
 	scaleByMapSize(4,16), 100
 );
 
 log("Creating small stone mines...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 1, clPlayer, 20, clRock, 10, clHill, 1),
 	scaleByMapSize(4,16), 100
 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 1),
 	scaleByMapSize(4,16), 100
 );
 RMS.SetProgress(70);
 
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockMedium, 1,3, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clForest, 0, clPlayer, 0, clHill, 0),
 	scaleByMapSize(16, 262), 50
 );
 
 log("Creating large decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clForest, 0, clPlayer, 0, clHill, 0),
 	scaleByMapSize(8, 131), 50
 );
 RMS.SetProgress(75);
 
 log("Creating deer...");
 group = new SimpleGroup(
 	[new SimpleObject(oDeer, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 10, clHill, 1, clFood, 20),
 	3 * numPlayers, 50
 );
 
 log("Creating berry bush...");
 group = new SimpleGroup(
 	[new SimpleObject(oBerryBush, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 20, clHill, 1, clFood, 10),
 	randIntInclusive(1, 4) * numPlayers + 2, 50
 );
 
 log("Creating rabbit...");
 group = new SimpleGroup(
 	[new SimpleObject(oRabbit, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 10, clHill, 1, clFood, 20),
 	3 * numPlayers, 50
 );
 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;
 
 group = new SimpleGroup(
 	[new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)]
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clHill, 2, clPlayer, 2, clDirt, 0),
 	planetm * 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,
 	avoidClasses(clHill, 2, clPlayer, 2, clDirt, 1, clForest, 0),
 	planetm * 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,
 	avoidClasses(clHill, 1, clPlayer, 1, clDirt, 1),
 	planetm * scaleByMapSize(13, 200), 50
 );
 
 setSkySet(pickRandom(["cirrus", "cumulus", "sunny"]));
 setSunRotation(randFloat(0, TWO_PI));
 setSunElevation(randFloat(PI/ 5, PI / 3));
 setWaterColor(0.0, 0.047, 0.286);				// dark majestic blue
 setWaterTint(0.471, 0.776, 0.863);				// light blue
 setWaterMurkiness(0.72);
 setWaterWaviness(2.0);
 setWaterType("lake");
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/anatolian_plateau.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/anatolian_plateau.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/anatolian_plateau.js	(revision 20301)
@@ -1,326 +1,309 @@
 RMS.LoadLibrary("rmgen");
 
 const tGrass = ["steppe_grass_a", "steppe_grass_b", "steppe_grass_c", "steppe_grass_d"];
 const tForestFloor = "steppe_grass_c";
 const tGrassA = "steppe_grass_b";
 const tGrassB = "steppe_grass_c";
 const tGrassC = ["steppe_grass_b", "steppe_grass_c", "steppe_grass_d"];
 const tGrassD = "steppe_grass_a";
 const tDirt = ["steppe_dirt_a", "steppe_dirt_b"];
 const tRoad = "road_stones";
 const tRoadWild = "road_stones";
 
 const oPoplar = "gaia/flora_tree_poplar_lombardy";
 const oBush = "gaia/flora_bush_temperate";
 const oBerryBush = "gaia/flora_bush_berry";
 const oRabbit = "gaia/fauna_rabbit";
 const oSheep = "gaia/fauna_sheep";
 const oStoneLarge = "gaia/geology_stonemine_medit_quarry";
 const oStoneSmall = "gaia/geology_stone_mediterranean";
 const oMetalLarge = "gaia/geology_metal_mediterranean_slabs";
 
 const aGrass = "actor|props/flora/grass_soft_small_tall.xml";
 const aGrassShort = "actor|props/flora/grass_soft_large.xml";
 const aRockLarge = "actor|geology/stone_granite_med.xml";
 const aRockMedium = "actor|geology/stone_granite_med.xml";
 const aBushMedium = "actor|props/flora/bush_medit_me.xml";
 const aBushSmall = "actor|props/flora/bush_medit_sm.xml";
 
 const pForest = [tForestFloor + TERRAIN_SEPARATOR + oPoplar, tForestFloor];
 
 InitMap();
 
 var numPlayers = getNumPlayers();
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 
 var [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 	addCivicCenterAreaToClass(ix, iz, clPlayer);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	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);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oBerryBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 	var hillSize = PI * radius * radius;
 	// create starting trees
 	var num = floor(hillSize / 100);
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(11, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oPoplar, num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 
 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;
 
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 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...");
 createLayeredPatches(
  [scaleByMapSize(5, 48), scaleByMapSize(6, 84), scaleByMapSize(8, 128)],
  [[tGrass,tGrassA,tGrassC],[tGrass,tGrassA,tGrassC], [tGrass,tGrassA,tGrassC]],
  [1,1],
  avoidClasses(clForest, 0, clHill, 0, clDirt, 2, clPlayer, 10),
  scaleByMapSize(50, 70),
  clDirt
 );
 
 log("Creating dirt patches...");
 createLayeredPatches(
  [scaleByMapSize(5, 32), scaleByMapSize(6, 48), scaleByMapSize(7, 80)],
  [tGrassD ,tDirt],
  [1],
  avoidClasses(clForest, 0, clHill, 0, clDirt, 2, clPlayer, 10),
  scaleByMapSize(50, 90),
  clDirt
 );
 
 RMS.SetProgress(55);
 
 log("Creating big patches...");
 createLayeredPatches(
  [scaleByMapSize(10, 60), scaleByMapSize(15, 90), scaleByMapSize(20, 120)],
  [tGrassB ,tGrassA],
  [1],
  avoidClasses(clHill, 0, clPlayer, 8),
  scaleByMapSize(30, 90),
  clDirt
 );
 
 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);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 1, clPlayer, 20, clRock, 10, clHill, 1),
 	scaleByMapSize(1,4), 100
 );
 
 log("Creating small stone quarries...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 1, clPlayer, 20, clRock, 10, clHill, 1),
 	scaleByMapSize(1,4), 100
 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 1),
 	scaleByMapSize(2,8), 100
 );
 
 RMS.SetProgress(65);
 
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockMedium, 1,3, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clForest, 0, clPlayer, 10, clHill, 0),
 	scaleByMapSize(16, 262), 50
 );
 
 log("Creating large decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clForest, 0, clPlayer, 10, clHill, 0),
 	scaleByMapSize(8, 131), 50
 );
 
 RMS.SetProgress(70);
 
 log("Creating rabbits...");
 group = new SimpleGroup(
 	[new SimpleObject(oRabbit, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 10, clHill, 1, clFood, 20),
 	6 * numPlayers, 50
 );
 
 log("Creating berry bush...");
 group = new SimpleGroup(
 	[new SimpleObject(oBerryBush, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 20, clHill, 1, clFood, 20),
 	randIntInclusive(1, 4) * numPlayers + 2, 50
 );
 
 RMS.SetProgress(75);
 
 log("Creating sheep...");
 group = new SimpleGroup(
 	[new SimpleObject(oSheep, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 10, clHill, 1, clFood, 20),
 	3 * numPlayers, 50
 );
 
 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(
 	[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,
 	avoidClasses(clHill, 2, clPlayer, 2, clDirt, 1, clForest, 0),
 	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,
 	avoidClasses(clHill, 1, clPlayer, 1, clDirt, 1),
 	scaleByMapSize(13, 200), 50
 );
 
 setFogThickness(0.1);
 setFogFactor(0.2);
 
 setPPEffect("hdr");
 setPPSaturation(0.45);
 setPPContrast(0.62);
 setPPBloom(0.2);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/archipelago.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/archipelago.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/archipelago.js	(revision 20301)
@@ -1,307 +1,312 @@
 RMS.LoadLibrary("rmgen");
 RMS.LoadLibrary("rmbiome");
 
 TILE_CENTERED_HEIGHT_MAP = true;
 
 setSelectedBiome();
 
 const tMainTerrain = g_Terrains.mainTerrain;
 const tForestFloor1 = g_Terrains.forestFloor1;
 const tForestFloor2 = g_Terrains.forestFloor2;
 const tCliff = g_Terrains.cliff;
 const tTier1Terrain = g_Terrains.tier1Terrain;
 const tTier2Terrain = g_Terrains.tier2Terrain;
 const tTier3Terrain = g_Terrains.tier3Terrain;
 const tHill = g_Terrains.hill;
 const tTier4Terrain = g_Terrains.dirt;
 const tRoad = g_Terrains.road;
 const tRoadWild = g_Terrains.roadWild;
 const tShore = g_Terrains.shore;
 const tWater = g_Terrains.water;
 
 const oTree1 = g_Gaia.tree1;
 const oTree2 = g_Gaia.tree2;
 const oTree3 = g_Gaia.tree3;
 const oTree4 = g_Gaia.tree4;
 const oTree5 = g_Gaia.tree5;
 const oFruitBush = g_Gaia.fruitBush;
 const oMainHuntableAnimal = g_Gaia.mainHuntableAnimal;
 const oFish = g_Gaia.fish;
 const oSecondaryHuntableAnimal = g_Gaia.secondaryHuntableAnimal;
 const oStoneLarge = g_Gaia.stoneLarge;
 const oStoneSmall = g_Gaia.stoneSmall;
 const oMetalLarge = g_Gaia.metalLarge;
 const oWood = "gaia/special_treasure_wood";
 
 const aGrass = g_Decoratives.grass;
 const aGrassShort = g_Decoratives.grassShort;
 const aRockLarge = g_Decoratives.rockLarge;
 const aRockMedium = g_Decoratives.rockMedium;
 const aBushMedium = g_Decoratives.bushMedium;
 const aBushSmall = g_Decoratives.bushSmall;
 
 const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
 const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clLand = createTileClass();
 
 var [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(22,31);
 	var shoreRadius = 4;
 	var elevation = 3;
 
 	var hillSize = PI * radius * radius;
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 
 	// create the main island
 	var placer = new ChainPlacer(2, floor(scaleByMapSize(5, 10)), floor(scaleByMapSize(25, 60)), 1, ix, iz, 0, [floor(radius)]);
 	var terrainPainter = new LayeredPainter(
 		[tMainTerrain , tMainTerrain, tMainTerrain],		// terrains
 		[1, shoreRadius]		// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		elevation,				// elevation
 		shoreRadius				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clPlayer)], null);
 
 	placeCivDefaultEntities(fx, fz, id, { 'iberWall': 'towers' });
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oFruitBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create woods
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 13;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oWood, 14,14, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 		mAngle = randFloat(0, TWO_PI);
 
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var num = floor(hillSize / 100);
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(11, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oTree1, num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 
 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);
 paintTerrainBasedOnHeight(-8, 1, 2, tWater);
 
 //creating the city patches for the players
 for (var i = 0; i < numPlayers; i++)
 {
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 	// create the city patch
 	var cityRadius = radius/3;
 	placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tRoadWild, tRoad], [1]);
 	createArea(placer, painter, null);
 }
 
 createBumps([avoidClasses(clPlayer, 10), stayClasses(clLand, 5)]);
 
 if (randBool())
 	createHills([tMainTerrain, tCliff, tHill], [avoidClasses(clPlayer, 2, clHill, 15), stayClasses(clLand, 0)], clHill, scaleByMapSize(1, 4) * numPlayers);
 else
 	createMountains(tCliff, [avoidClasses(clPlayer, 2, clHill, 15), stayClasses(clLand, 0)], clHill, scaleByMapSize(1, 4) * numPlayers);
 
 createForests(
  [tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
  [avoidClasses(clPlayer, 20, clForest, 17, clHill, 0), stayClasses(clLand, 4)],
  clForest,
  1,
  ...rBiomeTreeCount(1));
 RMS.SetProgress(50);
 
 log("Creating dirt patches...");
 createLayeredPatches(
  [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
  [[tMainTerrain,tTier1Terrain],[tTier1Terrain,tTier2Terrain], [tTier2Terrain,tTier3Terrain]],
  [1,1],
  [avoidClasses(clForest, 0, clHill, 0, clDirt, 3, clPlayer, 12), stayClasses(clLand, 7)]
 );
 
 log("Creating grass patches...");
 createPatches(
  [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
  tTier4Terrain,
  [avoidClasses(clForest, 0, clHill, 0, clDirt, 3, clPlayer, 12), stayClasses(clLand, 7)]
 );
 RMS.SetProgress(55);
 
 log("Creating stone mines...");
 createMines(
  [
   [new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)],
   [new SimpleObject(oStoneSmall, 2,5, 1,3)]
  ],
  [avoidClasses(clForest, 1, clPlayer, 7, clRock, 10, clHill, 1), stayClasses(clLand, 6)]
 );
 
 log("Creating metal mines...");
 createMines(
  [
   [new SimpleObject(oMetalLarge, 1,1, 0,4)]
  ],
  [avoidClasses(clForest, 1, clPlayer, 7, clMetal, 10, clRock, 5, clHill, 1), stayClasses(clLand, 6)],
  clMetal
 );
 RMS.SetProgress(65);
 
 log("Creating decoration...");
 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)],
   [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),
   planetm * scaleByMapSize(13, 200),
   planetm * scaleByMapSize(13, 200),
   planetm * scaleByMapSize(13, 200)
  ],
  [avoidClasses(clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 5)]
 );
 RMS.SetProgress(70);
 
 log("Creating animals...");
 createFood
 (
  [
   [new SimpleObject(oMainHuntableAnimal, 5,7, 0,4)],
   [new SimpleObject(oSecondaryHuntableAnimal, 2,3, 0,2)]
  ],
  [
   3 * numPlayers,
   3 * numPlayers
  ],
  [avoidClasses(clForest, 0, clPlayer, 1, clHill, 1, clFood, 20), stayClasses(clLand, 3)]
 );
 RMS.SetProgress(75);
 
 log("Creating fruits...");
 createFood
 (
  [
   [new SimpleObject(oFruitBush, 5,7, 0,4)]
  ],
  [
   3 * numPlayers
  ],
  [avoidClasses(clForest, 0, clPlayer, 1, clHill, 1, clFood, 10), stayClasses(clLand, 3)]
 );
 RMS.SetProgress(80);
 
 log("Creating fish...");
 createFood
 (
  [
   [new SimpleObject(oFish, 2,3, 0,2)]
  ],
  [
   25 * numPlayers
  ],
  avoidClasses(clLand, 3, clPlayer, 2, clFood, 20)
 );
 
 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");
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/ardennes_forest.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/ardennes_forest.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/ardennes_forest.js	(revision 20301)
@@ -1,578 +1,502 @@
 RMS.LoadLibrary("rmgen");
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 
 const tGrass = ["new_alpine_grass_b", "new_alpine_grass_c", "new_alpine_grass_d"];
 const tPineForestFloor = "temp_forestfloor_pine";
 const tForestFloor = [tPineForestFloor, tPineForestFloor, "alpine_dirt_grass_50"];
 const tCliff = ["alpine_cliff_c", "alpine_cliff_c", "alpine_grass_rocky"];
 const tCity = ["new_alpine_citytile", "new_alpine_grass_dirt_a"];
 const tGrassPatch = ["alpine_grass_a", "alpine_grass_b"];
 
 const oBoar = "gaia/fauna_boar";
 const oDeer = "gaia/fauna_deer";
 const oBear = "gaia/fauna_bear";
 const oPig = "gaia/fauna_pig";
 const oBerryBush = "gaia/flora_bush_berry";
 const oMetalSmall = "gaia/geology_metal_alpine";
 const oMetalLarge = "gaia/geology_metal_temperate_slabs";
 const oStoneSmall = "gaia/geology_stone_alpine_a";
 const oStoneLarge = "gaia/geology_stonemine_temperate_quarry";
 
 const oOak = "gaia/flora_tree_oak";
 const oOakLarge = "gaia/flora_tree_oak_large";
 const oPine = "gaia/flora_tree_pine";
 const oAleppoPine = "gaia/flora_tree_aleppo_pine";
 
 const aTreeA = "actor|flora/trees/oak.xml";
 const aTreeB = "actor|flora/trees/oak_large.xml";
 const aTreeC = "actor|flora/trees/pine.xml";
 const aTreeD = "actor|flora/trees/aleppo_pine.xml";
 
 const aTrees = [aTreeA, aTreeB, aTreeC, aTreeD];
 
 const aGrassLarge = "actor|props/flora/grass_soft_large.xml";
 const aWoodLarge = "actor|props/special/eyecandy/wood_pile_1_b.xml";
 const aWoodA = "actor|props/special/eyecandy/wood_sm_pile_a.xml";
 const aWoodB = "actor|props/special/eyecandy/wood_sm_pile_b.xml";
 const aBarrel = "actor|props/special/eyecandy/barrel_a.xml";
 const aWheel = "actor|props/special/eyecandy/wheel_laying.xml";
 const aCeltHomestead = "actor|structures/celts/homestead.xml";
 const aCeltHouse = "actor|structures/celts/house.xml";
 const aCeltLongHouse = "actor|structures/celts/longhouse.xml";
 
 var pForest = [
 		tPineForestFloor+TERRAIN_SEPARATOR+oOak, tForestFloor,
 		tPineForestFloor+TERRAIN_SEPARATOR+oPine, tForestFloor,
 		tPineForestFloor+TERRAIN_SEPARATOR+oAleppoPine, tForestFloor,
 		tForestFloor
 		];
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clForestJoin = createTileClass();
 var clWater = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 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);
 
 // Find all hills
 var noise0 = new Noise2D(20);
 for (var ix = 0; ix < mapSize; ix++)
 	for (var iz = 0; iz < mapSize; iz++)
 	{
 		var h = getHeight(ix,iz);
 		if(h > 40){
 			addToClass(ix,iz,clHill);
 
 			// Add hill noise
 			var x = ix / (mapSize + 1.0);
 			var z = iz / (mapSize + 1.0);
 			var n = (noise0.get(x,z) - 0.5) * 40;
 			setHeight(ix, iz, h + n);
 		}
 	}
 
 var [playerIDs, playerX, playerZ] = radialPlayerPlacement(0.3);
 
 function distanceToPlayers(x, z)
 {
 	var r = 10000;
 	for (var i = 0; i < numPlayers; i++)
 	{
 		var dx = x - playerX[i];
 		var dz = z - playerZ[i];
 		r = min(r, dx*dx + dz*dz);
 	}
 	return sqrt(r);
 }
 
 function playerNearness(x, z)
 {
 	var d = fractionToTiles(distanceToPlayers(x,z));
 
 	if (d < 13)
 		return 0;
 
 	if (d < 19)
 		return (d-13)/(19-13);
 
 	return 1;
 }
 
 RMS.SetProgress(10);
 
 for (var i=0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	var citySize = 250;
 
 	var placer = new ClumpPlacer(citySize, 0.95, 0.3, 0.1, ix, iz);
 	createArea(placer, [paintClass(clPlayer)], null);
 
 	// Create the city patch
 	var placer = new ClumpPlacer(citySize * 0.4, 0.6, 0.05, 10, ix, iz);
 	var painter = new TerrainPainter([tCity]);
 	createArea(placer, painter, null);
 
 	// Create starter animals
 	placeDefaultChicken(fx, fz, clBaseResource, undefined, oPig);
 
 	// Create starter berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oBerryBush, 3,3, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// Create starter metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = bbDist + 4;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// Create starter stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var num = 2;
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(11, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oOak, num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 }
 
 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
-		);
-	}
-
-	var placer = new ClumpPlacer(sizes[i], 0.1, 0.2, 0.1);
+			mountains);
 
-	var elevationPainter = new SmoothElevationPainter(
-	    ELEVATION_SET,
-	    10,
-	    2
-    );
-
-	var ravine = createAreas(
-		placer,
-		[painter, paintClass(clHill), elevationPainter],
+	let ravine = createAreas(
+		new ClumpPlacer(size, 0.1, 0.2, 0.1),
+		[
+			painter,
+			paintClass(clHill),
+			new SmoothElevationPainter(ELEVATION_SET, 10, 2)
+		],
 		avoidClasses(clPlayer, 6, clBaseResource, 2, clHill, 5),
-		scaleByMapSize(1, 3)
-	);
+		scaleByMapSize(1, 3));
 
-	if(sizes[i] > 150 && ravine.length > 0)
+	if (size > 150 && ravine.length)
 	{
-		// Place huts in ravines
-		var group = new RandomGroup(
-		[
-			new SimpleObject(aCeltHouse, 0,1, 4,5),
-			new SimpleObject(aCeltLongHouse, 1,1, 4,5)
-		], true, clHillDeco);
+		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);
 
 var explorableArea = {};
 explorableArea.points = [];
 
 var playerClass = getTileClass(clPlayer);
 var hillDecoClass = getTileClass(clHillDeco);
 
 for (var ix = 0; ix < mapSize; ix++)
 {
 	for (var iz = 0; iz < mapSize; iz++)
 	{
 		var h = getHeight(ix,iz);
 
 		if(h > 15 && h < 45 && playerClass.countMembersInRadius(ix, iz, 1) == 0)
 		{
 			// explorable area
 			var pt = {};
 			pt.x = ix;
 			pt.z = iz;
 			explorableArea.points.push(pt);
 		}
 
 		if (h > 35 && randBool(0.1) ||
 		    h < 15 && randBool(0.05) && hillDecoClass.countMembersInRadius(ix, iz, 1) == 0)
 			placeObject(ix + randFloat(0, 1), iz + randFloat(0, 1), pickRandom(aTrees), 0, randFloat(0, 2 * PI));
 	}
 }
 
 RMS.SetProgress(55);
 
 // Add some general noise - after placing height dependant trees
 for (var ix = 0; ix < mapSize; ix++)
 {
 	var x = ix / (mapSize + 1.0);
 	for (var iz = 0; iz < mapSize; iz++)
 	{
 		var z = iz / (mapSize + 1.0);
 		var h = getHeight(ix,iz);
 		var pn = playerNearness(x,z);
 		var n = (noise0.get(x,z) - 0.5) * 10;
 		setHeight(ix, iz, h + (n * pn));
 	}
 }
 
 RMS.SetProgress(60);
 
 // Calculate desired number of trees for map (based on size)
 const MIN_TREES = 400;
 const MAX_TREES = 6000;
 const P_FOREST = 0.8;
 const P_FOREST_JOIN = 0.25;
 
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 var numForest = totalTrees * P_FOREST * (1.0 - P_FOREST_JOIN);
 var numForestJoin = totalTrees * P_FOREST * P_FOREST_JOIN;
 var numStragglers = totalTrees * (1.0 - P_FOREST);
 
 log("Creating forests...");
 var num = numForest / (scaleByMapSize(6,16) * numPlayers);
 placer = new ClumpPlacer(numForest / num, 0.1, 0.1, 1);
 painter = new TerrainPainter(pForest);
 createAreasInAreas(
 	placer,
 	[painter, paintClass(clForest)],
 	avoidClasses(clPlayer, 5, clBaseResource, 4, clForest, 6, clHill, 4),
 	num,
 	100,
 	[explorableArea]
 );
 
 var num = numForestJoin / (scaleByMapSize(4,6) * numPlayers);
 placer = new ClumpPlacer(numForestJoin / num, 0.1, 0.1, 1);
 painter = new TerrainPainter(pForest);
 createAreasInAreas(
 	placer,
 	[painter, paintClass(clForest), paintClass(clForestJoin)],
 	[avoidClasses(clPlayer, 5, clBaseResource, 4, clForestJoin, 5, clHill, 4), borderClasses(clForest, 1, 4)],
 	num,
 	100,
 	[explorableArea]
 );
 
 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...");
 var group = new SimpleGroup([new SimpleObject(oStoneSmall, 1,2, 0,4), new SimpleObject(oStoneLarge, 0,1, 0,4)], true, clRock);
 createObjectGroupsByAreasDeprecated(group, 0,
 	[avoidClasses(clHill, 4, clForest, 2, clPlayer, 20, clRock, 10)],
 	scaleByMapSize(6,20), 100,
 	[explorableArea]
 );
 
 log("Creating small stone mines...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroupsByAreasDeprecated(group, 0,
 	[avoidClasses(clHill, 4, clForest, 2, clPlayer, 20, clRock, 10)],
 	scaleByMapSize(6,20), 100,
 	[explorableArea]
 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalSmall, 1,2, 0,4), new SimpleObject(oMetalLarge, 0,1, 0,4)], true, clMetal);
 createObjectGroupsByAreasDeprecated(group, 0,
 	[avoidClasses(clHill, 4, clForest, 2, clPlayer, 20, clMetal, 10, clRock, 5)],
 	scaleByMapSize(6,20), 100,
 	[explorableArea]
 );
 
 RMS.SetProgress(80);
 
 log("Creating wildlife...");
 group = new SimpleGroup(
 	[new SimpleObject(oDeer, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsByAreasDeprecated(group, 0,
 	avoidClasses(clHill, 4, clForest, 0, clPlayer, 0, clBaseResource, 20),
 	3 * numPlayers, 100,
 	[explorableArea]
 );
 
 group = new SimpleGroup(
 	[new SimpleObject(oBoar, 2,3, 0,5)],
 	true, clFood
 );
 createObjectGroupsByAreasDeprecated(group, 0,
 	avoidClasses(clHill, 4, clForest, 0, clPlayer, 0, clBaseResource, 15),
 	numPlayers, 50,
 	[explorableArea]
 );
 
 group = new SimpleGroup(
 	[new SimpleObject(oBear, 1,1, 0,4)],
 	false, clFood
 );
 createObjectGroupsByAreasDeprecated(group, 0,
 	avoidClasses(clHill, 4, clForest, 0, clPlayer, 20),
 	scaleByMapSize(3, 12), 200,
 	[explorableArea]
 );
 
 RMS.SetProgress(85);
 
 log("Creating berry bush...");
 group = new SimpleGroup(
 	[new SimpleObject(oBerryBush, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 4, clFood, 20),
 	randIntInclusive(3, 12) * numPlayers + 2, 50
 );
 
 log("Creating decorative props...");
 group = new SimpleGroup(
 	[
 		new SimpleObject(aWoodA, 1,2, 0,1),
 		new SimpleObject(aWoodB, 1,3, 0,1),
 		new SimpleObject(aWheel, 0,2, 0,1),
 		new SimpleObject(aWoodLarge, 0,1, 0,1),
 		new SimpleObject(aBarrel, 0,2, 0,1)
 	],
 	true
 );
 createObjectGroupsByAreasDeprecated(
 	group, 0,
 	avoidClasses(clForest, 0),
 	scaleByMapSize(5, 50), 50,
 	[explorableArea]
 );
 
 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);
 
 log("Creating grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aGrassLarge, 1,2, 0,1, -PI/8,PI/8)]
 );
 createObjectGroupsByAreasDeprecated(group, 0,
 	avoidClasses(clHill, 2, clPlayer, 2),
 	scaleByMapSize(50, 300), 20,
 	[explorableArea]
 );
 
 setTerrainAmbientColor(0.44,0.51,0.56);
 setUnitsAmbientColor(0.44,0.51,0.56);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/atlas_mountains.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/atlas_mountains.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/atlas_mountains.js	(revision 20301)
@@ -1,275 +1,271 @@
 RMS.LoadLibrary("rmgen");
 
 const tGrass = ["medit_rocks_grass_shrubs", "medit_rocks_shrubs"];
 const tForestFloor = "medit_grass_field_dry";
 const tCliff = "medit_cliff_italia";
 const tGrassDirt = "medit_rocks_grass";
 const tDirt = "medit_dirt";
 const tRoad = "medit_city_tile";
 const tRoadWild = "medit_city_tile";
 const tGrass2 = "medit_rocks_grass_shrubs";
 const tGrassPatch = "medit_grass_wild";
 
 const oCarob = "gaia/flora_tree_carob";
 const oAleppoPine = "gaia/flora_tree_aleppo_pine";
 const oBerryBush = "gaia/flora_bush_berry";
 const oDeer = "gaia/fauna_deer";
 const oSheep = "gaia/fauna_sheep";
 const oStoneLarge = "gaia/geology_stonemine_medit_quarry";
 const oStoneSmall = "gaia/geology_stone_mediterranean";
 const oMetalLarge = "gaia/geology_metal_mediterranean_slabs";
 const oWood = "gaia/special_treasure_wood";
 const oFood = "gaia/special_treasure_food_bin";
 
 const aGrass = "actor|props/flora/grass_soft_large_tall.xml";
 const aGrassShort = "actor|props/flora/grass_soft_large.xml";
 const aRockLarge = "actor|geology/stone_granite_large.xml";
 const aRockMedium = "actor|geology/stone_granite_med.xml";
 const aBushMedium = "actor|props/flora/bush_medit_me.xml";
 const aBushSmall = "actor|props/flora/bush_medit_sm.xml";
 const aCarob = "actor|flora/trees/carob.xml";
 const aAleppoPine = "actor|flora/trees/aleppo_pine.xml";
 
 // terrain + entity (for painting)
 const pForest1 = [tForestFloor + TERRAIN_SEPARATOR + oCarob, tForestFloor];
 const pForest2 = [tForestFloor + TERRAIN_SEPARATOR + oAleppoPine, tForestFloor];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clTreasure = createTileClass();
 var clGrass = createTileClass();
 
 var [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 	addCivicCenterAreaToClass(ix, iz, clPlayer);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	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);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oBerryBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 	// create starting trees
 	var num = 4;
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(11, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oCarob, num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 
 RMS.SetProgress(10);
 
 createBumps(avoidClasses(clPlayer, 9));
 
 createMountains(tCliff, avoidClasses(clPlayer, 20, clHill, 8), clHill, scaleByMapSize(20, 120));
 
 RMS.SetProgress(25);
 
 createForests(
  [tGrass, tForestFloor, tForestFloor, pForest1, pForest2],
  avoidClasses(clPlayer, 20, clForest, 14, clHill, 1),
  clForest,
  0.6);
 
 RMS.SetProgress(40);
 
 log("Creating dirt patches...");
 createLayeredPatches(
  [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
  [tGrassDirt,tDirt],
  [2],
  avoidClasses(clForest, 0, clHill, 0, clDirt, 3, clPlayer, 10)
 );
 
 log("Creating grass patches...");
 createLayeredPatches(
  [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
  [tGrass2,tGrassPatch],
  [1],
  avoidClasses(clForest, 0, clHill, 0, clDirt, 3, clPlayer, 10, clGrass, 15)
 );
 
 RMS.SetProgress(50);
 
 log("Creating stone mines...");
 createMines(
  [
   [new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)],
   [new SimpleObject(oStoneSmall, 2,5, 1,3)]
  ],
  avoidClasses(clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 2)
 );
 
 log("Creating metal mines...");
 createMines(
  [
   [new SimpleObject(oMetalLarge, 1,1, 0,4)]
  ],
  avoidClasses(clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 2),
  clMetal
 );
 
 RMS.SetProgress(60);
 
 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),
   scaleByMapSize(13, 200),
   scaleByMapSize(13, 200),
   scaleByMapSize(13, 200)
  ],
  avoidClasses(clForest, 0, clPlayer, 0, clHill, 0)
 );
 
 RMS.SetProgress(75);
 
 createFood
 (
  [
   [new SimpleObject(oSheep, 5,7, 0,4)],
   [new SimpleObject(oDeer, 2,3, 0,2)]
  ],
  [
   3 * numPlayers,
   3 * numPlayers
  ]
 );
 
 createFood
 (
  [
   [new SimpleObject(oBerryBush, 5,7, 0,4)]
  ],
  [
   randIntInclusive(3, 12) * numPlayers + 2
  ],
  avoidClasses(clForest, 0, clPlayer, 20, clHill, 1, clFood, 10)
 );
 
 log("Creating food treasures...");
 group = new SimpleGroup(
 	[new SimpleObject(oFood, 2,3, 0,2)],
 	true, clTreasure
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 18, clHill, 1, clFood, 5),
 	3 * numPlayers, 50
 );
 
 log("Creating food treasures...");
 group = new SimpleGroup(
 	[new SimpleObject(oWood, 2,3, 0,2)],
 	true, clTreasure
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 18, clHill, 1),
 	3 * numPlayers, 50
 );
 
 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);
 
 setPPEffect("hdr");
 setPPContrast(0.45);
 setPPSaturation(0.56);
 setPPBloom(0.1);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/cantabrian_highlands.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/cantabrian_highlands.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/cantabrian_highlands.js	(revision 20301)
@@ -1,324 +1,322 @@
 RMS.LoadLibrary("rmgen");
 
 const tGrass = ["temp_grass", "temp_grass", "temp_grass_d"];
 const tGrassPForest = "temp_plants_bog";
 const tGrassDForest = "temp_plants_bog";
 const tGrassA = "temp_grass_plants";
 const tGrassB = "temp_plants_bog";
 const tGrassC = "temp_mud_a";
 const tHill = ["temp_highlands", "temp_grass_long_b"];
 const tCliff = ["temp_cliff_a", "temp_cliff_b"];
 const tRoad = "temp_road";
 const tRoadWild = "temp_road_overgrown";
 const tGrassPatchBlend = "temp_grass_long_b";
 const tGrassPatch = ["temp_grass_d", "temp_grass_clovers"];
 const tShoreBlend = "temp_grass_plants";
 const tShore = "temp_plants_bog";
 const tWater = "temp_mud_a";
 
 const oOak = "gaia/flora_tree_oak";
 const oOakLarge = "gaia/flora_tree_oak_large";
 const oApple = "gaia/flora_tree_apple";
 const oPine = "gaia/flora_tree_pine";
 const oAleppoPine = "gaia/flora_tree_aleppo_pine";
 const oBerryBush = "gaia/flora_bush_berry";
 const oDeer = "gaia/fauna_deer";
 const oFish = "gaia/fauna_fish";
 const oSheep = "gaia/fauna_sheep";
 const oStoneLarge = "gaia/geology_stonemine_temperate_quarry";
 const oStoneSmall = "gaia/geology_stone_temperate";
 const oMetalLarge = "gaia/geology_metal_temperate_slabs";
 
 const aGrass = "actor|props/flora/grass_soft_large_tall.xml";
 const aGrassShort = "actor|props/flora/grass_soft_large.xml";
 const aReeds = "actor|props/flora/reeds_pond_lush_a.xml";
 const aLillies = "actor|props/flora/pond_lillies_large.xml";
 const aRockLarge = "actor|geology/stone_granite_large.xml";
 const aRockMedium = "actor|geology/stone_granite_med.xml";
 const aBushMedium = "actor|props/flora/bush_medit_me.xml";
 const aBushSmall = "actor|props/flora/bush_medit_sm.xml";
 
 // terrain + entity (for painting)
 const pForestD = [tGrassDForest + TERRAIN_SEPARATOR + oOak, tGrassDForest + TERRAIN_SEPARATOR + oOakLarge, tGrassDForest];
 const pForestP = [tGrassPForest + TERRAIN_SEPARATOR + oPine, tGrassPForest + TERRAIN_SEPARATOR + oAleppoPine, tGrassPForest];
 
 InitMap();
 
 var numPlayers = getNumPlayers();
 var mapSize = getMapSize();
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 
 var [playerIDs, playerX, playerZ, playerAngle] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 
 	// calculate size based on the radius
 	var hillSize = PI * radius * radius;
 
 	// create the hill
 	var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 	var terrainPainter = new LayeredPainter(
 		[tCliff, tHill],		// terrains
 		[cliffRadius]		// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		elevation,				// elevation
 		cliffRadius				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clPlayer)], null);
 
 	// create the ramp
 	var rampAngle = playerAngle[i] + PI + randFloat(-PI/8, PI/8);
 	var rampDist = radius;
 	var rampLength = 15;
 	var rampWidth = 12;
 	var rampX1 = round(fx + (rampDist + rampLength) * cos(rampAngle));
 	var rampZ1 = round(fz + (rampDist + rampLength) * sin(rampAngle));
 	var rampX2 = round(fx + (rampDist - 3) * cos(rampAngle));
 	var rampZ2 = round(fz + (rampDist - 3) * sin(rampAngle));
 
 	createRamp (rampX1, rampZ1, rampX2, rampZ2, 3, 20, rampWidth, 2, tHill, tCliff, clPlayer);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tRoadWild, tRoad], [1]);
 	createArea(placer, painter, null);
 
 	placeCivDefaultEntities(fx, fz, id, { 'iberWall': false });
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oBerryBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 		mAngle = randFloat(0, TWO_PI);
 
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var num = 2;
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(11, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oOak, num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 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
 );
 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,
 	[borderClasses(clWater, 3, 0), stayClasses(clWater, 1)],
 	numLakes, 100,
 	waterAreas
 );
 RMS.SetProgress(20);
 
 log("Creating fish...");
 createObjectGroupsByAreasDeprecated(
 	new SimpleGroup(
 		[new SimpleObject(oFish, 1,1, 0,1)],
 		true, clFood
 	),
 	0,
 	[stayClasses(clWater, 4),  avoidClasses(clFood, 8)],
 	numLakes / 4,
 	50,
 	waterAreas
 );
 RMS.SetProgress(25);
 
 createBumps(avoidClasses(clWater, 2, clPlayer, 0));
 RMS.SetProgress(30);
 
 log("Creating hills...");
 createHills([tCliff, tCliff, tHill], avoidClasses(clPlayer, 2, clWater, 5, clHill, 15), clHill, scaleByMapSize(1, 4) * numPlayers);
 RMS.SetProgress(35);
 
 createForests(
  [tGrass, tGrassDForest, tGrassPForest, pForestP, pForestD],
  avoidClasses(clPlayer, 1, clWater, 3, clForest, 17, clHill, 1),
  clForest
 );
 RMS.SetProgress(40);
 
 log("Creating dirt patches...");
 createLayeredPatches(
  [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
  [[tGrass,tGrassA],[tGrassA,tGrassB], [tGrassB,tGrassC]],
  [1,1],
  avoidClasses(clWater, 1, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 0)
 );
 RMS.SetProgress(45);
 
 log("Creating grass patches...");
 createLayeredPatches(
  [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
  [tGrassPatchBlend, tGrassPatch],
  [1],
  avoidClasses(clWater, 1, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 0)
 );
 RMS.SetProgress(50);
 
 log("Creating stone mines...");
 createMines(
  [
   [new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)],
   [new SimpleObject(oStoneSmall, 2,5, 1,3)]
  ],
  avoidClasses(clWater, 0, clForest, 1, clPlayer, 5, clRock, 10, clHill, 1)
 );
 RMS.SetProgress(55);
 
 log("Creating metal mines...");
 createMines(
  [
   [new SimpleObject(oMetalLarge, 1,1, 0,4)]
  ],
  avoidClasses(clWater, 0, clForest, 1, clPlayer, 5, clMetal, 10, clRock, 5, clHill, 1),
  clMetal
 );
 RMS.SetProgress(60);
 
 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),
   scaleByMapSize(13, 200),
   scaleByMapSize(13, 200),
   scaleByMapSize(13, 200)
  ],
  avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0)
 );
 RMS.SetProgress(70);
 
 createFood
 (
  [
   [new SimpleObject(oSheep, 2,3, 0,2)],
   [new SimpleObject(oDeer, 5,7, 0,4)]
  ],
  [
   3 * numPlayers,
   3 * numPlayers
  ],
  avoidClasses(clWater, 0, clForest, 0, clPlayer, 1, clHill, 1, clFood, 20)
 );
 RMS.SetProgress(80);
 
 createFood
 (
  [
   [new SimpleObject(oBerryBush, 5,7, 0,4)]
  ],
  [
   randIntInclusive(1, 4) * numPlayers + 2
  ],
  avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 10)
 );
 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");
 
 setFogThickness(0.25);
 setFogFactor(0.4);
 
 setPPEffect("hdr");
 setPPSaturation(0.62);
 setPPContrast(0.62);
 setPPBloom(0.3);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/canyon.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/canyon.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/canyon.js	(revision 20301)
@@ -1,453 +1,420 @@
 RMS.LoadLibrary("rmgen");
 RMS.LoadLibrary("rmbiome");
 
 setSelectedBiome();
 
 const tMainTerrain = g_Terrains.mainTerrain;
 const tForestFloor1 = g_Terrains.forestFloor1;
 const tForestFloor2 = g_Terrains.forestFloor2;
 const tCliff = g_Terrains.cliff;
 const tTier1Terrain = g_Terrains.tier1Terrain;
 const tTier2Terrain = g_Terrains.tier2Terrain;
 const tTier3Terrain = g_Terrains.tier3Terrain;
 const tHill = g_Terrains.hill;
 const tRoad = g_Terrains.road;
 const tRoadWild = g_Terrains.roadWild;
 const tTier4Terrain = g_Terrains.tier4Terrain;
 
 const oTree1 = g_Gaia.tree1;
 const oTree2 = g_Gaia.tree2;
 const oTree3 = g_Gaia.tree3;
 const oTree4 = g_Gaia.tree4;
 const oTree5 = g_Gaia.tree5;
 const oFruitBush = g_Gaia.fruitBush;
 const oMainHuntableAnimal = g_Gaia.mainHuntableAnimal;
 const oSecondaryHuntableAnimal = g_Gaia.secondaryHuntableAnimal;
 const oStoneLarge = g_Gaia.stoneLarge;
 const oStoneSmall = g_Gaia.stoneSmall;
 const oMetalLarge = g_Gaia.metalLarge;
 const oWood = "gaia/special_treasure_wood";
 const oFood = "gaia/special_treasure_food_bin";
 
 const aGrass = g_Decoratives.grass;
 const aGrassShort = g_Decoratives.grassShort;
 const aRockLarge = g_Decoratives.rockLarge;
 const aRockMedium = g_Decoratives.rockMedium;
 const aBushMedium = g_Decoratives.bushMedium;
 const aBushSmall = g_Decoratives.bushSmall;
 const aTree = g_Decoratives.tree;
 
 const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
 const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
 
 InitMap();
 
 var numPlayers = getNumPlayers();
 var mapSize = getMapSize();
 var mapArea = mapSize*mapSize;
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clHill2 = createTileClass();
 var clForest = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clLand = createTileClass();
 
-initTerrain(tMainTerrain);
+var landHeight = 3;
+var hillHeight = 30;
 
-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);
+initTerrain(tMainTerrain);
 
 var [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(18,32);
 	var cliffRadius = 2;
 	var elevation = 20;
 	var hillSize = PI * radius * radius;
 	// get the x and z in tiles
 	fx = fractionToTiles(playerX[i]);
 	fz = fractionToTiles(playerZ[i]);
 	ix = round(fx);
 	iz = round(fz);
 	// create the hill
 	var placer = new ClumpPlacer(hillSize, 0.65, 0.1, 10, ix, iz);
 	var terrainPainter = new LayeredPainter(
 		[tMainTerrain, tMainTerrain],		// terrains
 		[cliffRadius]		// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		3,				// elevation
 		cliffRadius				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oFruitBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = 11;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 	var hillSize = PI * radius * radius;
 	// create starting trees
 	var num = floor(hillSize / 100);
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = 12;
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oTree1, num, num, 0,4)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 
 	// create the city patch
 	var cityRadius = radius/2;
 	placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, fractionToTiles(playerX[i]), fractionToTiles(playerZ[i]));
 	var painter = new LayeredPainter([tMainTerrain, tMainTerrain], [1]);
 	createArea(placer, [painter, paintClass(clPlayer)], 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);
-
-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);
-
-	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));
-}
+log("Creating center area...");
+var center = Math.round(fractionToTiles(0.5));
+var lSize = Math.pow(scaleByMapSize(1, 6), 1/8);
+
+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);
+
+createArea(
+	new ClumpPlacer(150, 0.6, 0.3, 10, center, center),
+	paintClass(clHill),
+	null);
+
+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 (var g = 0; g < scaleByMapSize(5,30); g++)
+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 = [];
 		var d1 = 9999;
 		var d2 = 9999;
 		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])
 			{
 				d2 = d1;
 				d1 = distances[a];
 				p2 = p1;
 				p1 = a;
 			}
 			else if (d2 >= distances[a])
 			{
 				d2 = distances[a];
 				p2 = a;
 			}
 		}
 
-		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);
-		}
-	}
-}
-
-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);
+			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);
 	}
-	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);
 
 paintTerrainBasedOnHeight(3.1, 29, 0, tCliff);
 paintTileClassBasedOnHeight(3.1, 32, 0, clHill2);
 
 createBumps([avoidClasses(clPlayer, 2), stayClasses(clLand, 2)]);
 
 createHills([tCliff, tCliff, tHill], [avoidClasses(clPlayer, 2, clHill, 8, clHill2, 8), stayClasses(clLand, 5)], clHill, scaleByMapSize(10, 40));
 
 // create hills outside the canyon
 createHills([tCliff, tCliff, tMainTerrain], avoidClasses(clLand, 1, clHill, 1), clHill, scaleByMapSize(20, 150), undefined, undefined, undefined, undefined, 40);
 
 createForests(
  [tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
  [avoidClasses(clPlayer, 1, clForest, 15, clHill, 1, clHill2, 0), stayClasses(clLand, 4)],
  clForest,
  1,
  ...rBiomeTreeCount(1)
 );
 
 RMS.SetProgress(50);
 
 log("Creating dirt patches...");
 createLayeredPatches(
  [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
  [[tMainTerrain,tTier1Terrain],[tTier1Terrain,tTier2Terrain], [tTier2Terrain,tTier3Terrain]],
  [1,1],
  [avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 4, clHill2, 0), stayClasses(clLand, 3)]
 );
 
 log("Creating grass patches...");
 createPatches(
  [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
  tTier4Terrain,
  [avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 4, clHill2, 0), stayClasses(clLand, 3)]
 );
 
 log("Creating stone mines...");
 createMines(
  [
   [new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)],
   [new SimpleObject(oStoneSmall, 2,5, 1,3)]
  ],
  [avoidClasses(clForest, 1, clPlayer, 3, clRock, 10, clHill, 1, clHill2, 1), stayClasses(clLand, 2)]
 );
 
 log("Creating metal mines...");
 createMines(
  [
   [new SimpleObject(oMetalLarge, 1,1, 0,4)]
  ],
  [avoidClasses(clForest, 1, clPlayer, 3, clMetal, 10, clRock, 5, clHill, 1, clHill2, 1), stayClasses(clLand, 2)],
  clMetal
 );
 
 RMS.SetProgress(65);
 
 var planetm = 1;
 
 if (currentBiome() == "tropic")
 	planetm = 8;
 
 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)]
  ],
  [
   3*scaleByMapSize(16, 262),
   3*scaleByMapSize(8, 131),
   planetm * scaleByMapSize(13, 200),
   planetm * scaleByMapSize(13, 200),
   planetm * scaleByMapSize(13, 200)
  ],
  avoidClasses(clForest, 0, clPlayer, 0, clHill, 0)
 );
 
 log("Creating actor trees...");
 group = new SimpleGroup(
 	[new SimpleObject(aTree, 1,1, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clLand, 5),
 	scaleByMapSize(200, 800), 50
 );
 
 RMS.SetProgress(70);
 
 createFood
 (
  [
   [new SimpleObject(oMainHuntableAnimal, 5,7, 0,4)],
   [new SimpleObject(oSecondaryHuntableAnimal, 2,3, 0,2)]
  ],
  [
   3 * numPlayers,
   3 * numPlayers
  ],
  [avoidClasses(clForest, 0, clPlayer, 4, clHill, 1, clFood, 20, clHill2, 1), stayClasses(clLand, 3)]
 );
 
 createFood
 (
  [
   [new SimpleObject(oFruitBush, 5,7, 0,4)]
  ],
  [
   3 * numPlayers
  ],
  [avoidClasses(clForest, 0, clPlayer, 4, clHill, 1, clFood, 10, clHill2, 1), stayClasses(clLand, 3)]
 );
 
 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();
Index: ps/trunk/binaries/data/mods/public/maps/random/continent.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/continent.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/continent.js	(revision 20301)
@@ -1,300 +1,300 @@
 RMS.LoadLibrary("rmgen");
 RMS.LoadLibrary("rmbiome");
 
 setSelectedBiome();
 
 const tMainTerrain = g_Terrains.mainTerrain;
 const tForestFloor1 = g_Terrains.forestFloor1;
 const tForestFloor2 = g_Terrains.forestFloor2;
 const tCliff = g_Terrains.cliff;
 const tTier1Terrain = g_Terrains.tier1Terrain;
 const tTier2Terrain = g_Terrains.tier2Terrain;
 const tTier3Terrain = g_Terrains.tier3Terrain;
 const tHill = g_Terrains.hill;
 const tRoad = g_Terrains.road;
 const tRoadWild = g_Terrains.roadWild;
 const tTier4Terrain = g_Terrains.tier4Terrain;
 const tShore = g_Terrains.shore;
 const tWater = g_Terrains.water;
 
 const oTree1 = g_Gaia.tree1;
 const oTree2 = g_Gaia.tree2;
 const oTree3 = g_Gaia.tree3;
 const oTree4 = g_Gaia.tree4;
 const oTree5 = g_Gaia.tree5;
 const oFruitBush = g_Gaia.fruitBush;
 const oMainHuntableAnimal = g_Gaia.mainHuntableAnimal;
 const oFish = g_Gaia.fish;
 const oSecondaryHuntableAnimal = g_Gaia.secondaryHuntableAnimal;
 const oStoneLarge = g_Gaia.stoneLarge;
 const oStoneSmall = g_Gaia.stoneSmall;
 const oMetalLarge = g_Gaia.metalLarge;
 
 const aGrass = g_Decoratives.grass;
 const aGrassShort = g_Decoratives.grassShort;
 const aRockLarge = g_Decoratives.rockLarge;
 const aRockMedium = g_Decoratives.rockMedium;
 const aBushMedium = g_Decoratives.bushMedium;
 const aBushSmall = g_Decoratives.bushSmall;
 
 const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
 const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
 
 InitMap();
 
 var numPlayers = getNumPlayers();
 var mapSize = getMapSize();
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 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);
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	fx = fractionToTiles(playerX[i]);
 	fz = fractionToTiles(playerZ[i]);
 	ix = round(fx);
 	iz = round(fz);
 	addCivicCenterAreaToClass(ix, iz, clPlayer);
 
 	var placer = new ChainPlacer(2, floor(scaleByMapSize(5, 9)), floor(scaleByMapSize(5, 20)), 1, ix, iz, 0, [floor(scaleByMapSize(23, 50))]);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		3,				// elevation
 		4				// blend radius
 	);
 	createArea(placer, [elevationPainter, paintClass(clLand)], null);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oFruitBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var num = 2;
 	var tAngle = randFloat(0, TWO_PI);
 	var tDist = randFloat(12, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oTree1, num, num, 0,3)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 
 RMS.SetProgress(20);
 
 paintTerrainBasedOnHeight(3, 4, 3, tMainTerrain);
 paintTerrainBasedOnHeight(1, 3, 0, tShore);
 paintTerrainBasedOnHeight(-8, 1, 2, tWater);
 
 for (var i = 0; i < numPlayers; ++i)
 {
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	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);
 }
 
 createBumps([avoidClasses(clPlayer, 10), stayClasses(clLand, 5)]);
 
 if (randBool())
 	createHills([tMainTerrain, tCliff, tHill], [avoidClasses(clPlayer, 20, clHill, 15, clBaseResource, 3), stayClasses(clLand, 5)], clHill, scaleByMapSize(1, 4) * numPlayers);
 else
 	createMountains(tCliff, [avoidClasses(clPlayer, 20, clHill, 15, clBaseResource, 3), stayClasses(clLand, 5)], clHill, scaleByMapSize(1, 4) * numPlayers);
 
 createForests(
  [tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
  [avoidClasses(clPlayer, 20, clForest, 17, clHill, 0, clBaseResource,2), stayClasses(clLand, 4)],
  clForest,
  1.0,
  ...rBiomeTreeCount(1));
 
 RMS.SetProgress(50);
 
 log("Creating dirt patches...");
 createLayeredPatches(
  [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
  [[tMainTerrain,tTier1Terrain],[tTier1Terrain,tTier2Terrain], [tTier2Terrain,tTier3Terrain]],
  [1,1],
  [avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12), stayClasses(clLand, 5)]
 );
 
 log("Creating grass patches...");
 createPatches(
  [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
  tTier4Terrain,
  [avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12), stayClasses(clLand, 5)]
 );
 
 RMS.SetProgress(55);
 
 log("Creating stone mines...");
 createMines(
  [
   [new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)],
   [new SimpleObject(oStoneSmall, 2,5, 1,3)]
  ],
  [avoidClasses(clForest, 1, clPlayer, 20, clRock, 10, clHill, 1), stayClasses(clLand, 6)]
 );
 
 log("Creating metal mines...");
 createMines(
  [
   [new SimpleObject(oMetalLarge, 1,1, 0,4)]
  ],
  [avoidClasses(clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 1), stayClasses(clLand, 6)],
  clMetal
 );
 
 RMS.SetProgress(65);
 
 // create decoration
 var planetm = 1;
 
 if (currentBiome() == "tropic")
 	planetm = 8;
 
 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),
   planetm * scaleByMapSize(13, 200),
   planetm * scaleByMapSize(13, 200),
   planetm * scaleByMapSize(13, 200)
  ],
  [avoidClasses(clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 5)]
 );
 
 RMS.SetProgress(70);
 
 createFood
 (
  [
   [new SimpleObject(oMainHuntableAnimal, 5,7, 0,4)],
   [new SimpleObject(oSecondaryHuntableAnimal, 2,3, 0,2)]
  ],
  [
   3 * numPlayers,
   3 * numPlayers
  ],
  [avoidClasses(clForest, 0, clPlayer, 20, clHill, 1, clFood, 20), stayClasses(clLand, 5)]
 );
 
 createFood
 (
  [
   [new SimpleObject(oFruitBush, 5,7, 0,4)]
  ],
  [
   3 * numPlayers
  ],
  [avoidClasses(clForest, 0, clPlayer, 20, clHill, 1, clFood, 10), stayClasses(clLand, 5)]
 );
 
 createFood
 (
  [
   [new SimpleObject(oFish, 2,3, 0,2)]
  ],
  [
   25 * numPlayers
  ],
  avoidClasses(clLand, 2, clFood, 20)
 );
 
 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");
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/corinthian_isthmus.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/corinthian_isthmus.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/corinthian_isthmus.js	(revision 20301)
@@ -1,322 +1,323 @@
 RMS.LoadLibrary("rmgen");
 
 TILE_CENTERED_HEIGHT_MAP = true;
 
 const tCity = "medit_city_pavement";
 const tCityPlaza = "medit_city_pavement";
 const tHill = ["medit_grass_shrubs", "medit_rocks_grass_shrubs", "medit_rocks_shrubs", "medit_rocks_grass", "medit_shrubs"];
 const tMainDirt = "medit_dirt";
 const tCliff = "medit_cliff_aegean";
 const tForestFloor = "medit_grass_shrubs";
 const tGrass = ["medit_grass_field", "medit_grass_field_a"];
 const tGrassSand50 = "medit_grass_field_a";
 const tGrassSand25 = "medit_grass_field_b";
 const tDirt = "medit_dirt_b";
 const tDirt2 = "medit_rocks_grass";
 const tDirt3 = "medit_rocks_shrubs";
 const tDirtCracks = "medit_dirt_c";
 const tShore = "medit_sand";
 const tWater = "medit_sand_wet";
 
 const oBerryBush = "gaia/flora_bush_berry";
 const oDeer = "gaia/fauna_deer";
 const oFish = "gaia/fauna_fish";
 const oSheep = "gaia/fauna_sheep";
 const oGoat = "gaia/fauna_goat";
 const oStoneLarge = "gaia/geology_stonemine_medit_quarry";
 const oStoneSmall = "gaia/geology_stone_mediterranean";
 const oMetalLarge = "gaia/geology_metal_mediterranean_slabs";
 const oDatePalm = "gaia/flora_tree_cretan_date_palm_short";
 const oSDatePalm = "gaia/flora_tree_cretan_date_palm_tall";
 const oCarob = "gaia/flora_tree_carob";
 const oFanPalm = "gaia/flora_tree_medit_fan_palm";
 const oPoplar = "gaia/flora_tree_poplar_lombardy";
 const oCypress = "gaia/flora_tree_cypress";
 
 const aBush1 = "actor|props/flora/bush_medit_sm.xml";
 const aBush2 = "actor|props/flora/bush_medit_me.xml";
 const aBush3 = "actor|props/flora/bush_medit_la.xml";
 const aBush4 = "actor|props/flora/bush_medit_me.xml";
 const aDecorativeRock = "actor|geology/stone_granite_med.xml";
 
 const pForest = [tForestFloor, tForestFloor + TERRAIN_SEPARATOR + oCarob, tForestFloor + TERRAIN_SEPARATOR + oDatePalm, tForestFloor + TERRAIN_SEPARATOR + oSDatePalm, tForestFloor];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 
 var clPlayer = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clGrass = createTileClass();
 var clHill = createTileClass();
 
 var landHeight = getMapBaseHeight();
 var waterHeight = -4;
 
 var riverWidth = scaleByMapSize(15, 70);
 var riverAngle = -Math.PI / 4;
 
 var riv1 = [0, 0.5];
 var riv2 = [1, 0.5];
 
 log("Creating the main river");
 var [riverX1, riverZ1] = rotateCoordinates(...riv1, riverAngle).map(f => fractionToTiles(f));
 var [riverX2, riverZ2] = rotateCoordinates(...riv2, riverAngle).map(f => fractionToTiles(f));
 createArea(
 	new PathPlacer(riverX1, riverZ1, riverX2, riverZ2, riverWidth, 0.2, 15 * scaleByMapSize(1, 3), 0.04, 0.01),
 	new SmoothElevationPainter(ELEVATION_SET, waterHeight, 4),
 	null);
 
 log("Creating small puddles at the map border to ensure players being separated...");
 for (let [x, z] of [[riverX1, riverZ1], [riverX2, riverZ2]])
 	createArea(
 		new ClumpPlacer(Math.floor(Math.PI * Math.pow(riverWidth / 2, 2)), 0.95, 0.6, 10, x, z),
 		new SmoothElevationPainter(ELEVATION_SET, waterHeight, 4),
 		null);
 
 log("Creating passage connecting the two riversides...");
 createArea(
 	new PathPlacer(
 		...rotateCoordinates(...riv1, riverAngle + Math.PI / 2).map(f => fractionToTiles(f)),
 		...rotateCoordinates(...riv2, riverAngle + Math.PI / 2).map(f => fractionToTiles(f)),
 		scaleByMapSize(10, 30),
 		0.5,
 		3 * scaleByMapSize(1, 4),
 		0.1,
 		0.01),
 	new SmoothElevationPainter(ELEVATION_SET, landHeight, 4),
 	null);
 
 paintTerrainBasedOnHeight(-6, 1, 1, tWater);
 paintTerrainBasedOnHeight(1, 2, 1, tShore);
 paintTerrainBasedOnHeight(2, 5, 1, tGrass);
 
 paintTileClassBasedOnHeight(-6, 0.5, 1, clWater);
 
 var playerIDs = primeSortAllPlayers();
 var playerPos = placePlayersRiver();
 
 var playerX = [];
 var playerZ = [];
 
 for (var i = 0; i < numPlayers; i++)
 {
 	playerZ[i] = Math.sqrt(0.5)*(0.6*(i%2) - 0.8 + playerPos[i]) + 0.5;
 	playerX[i] = Math.sqrt(0.5)*(0.6*(i%2) + 0.2 - playerPos[i]) + 0.5;
 }
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = floor(fx);
 	var iz = floor(fz);
 	addToClass(ix, iz, clPlayer);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	var placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tCityPlaza, tCity], [1]);
 	createArea(placer, painter, null);
 
 	placeCivDefaultEntities(fx, fz, id, { 'iberWall': 'towers' });
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oBerryBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var num = 2;
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(11, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oCarob, num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aBush1, clBaseResource, radius);
 }
 
 RMS.SetProgress(40);
 
 createBumps(avoidClasses(clWater, 2, clPlayer, 20));
 
 createForests(
  [tForestFloor, tForestFloor, tForestFloor, pForest, pForest],
  avoidClasses(clPlayer, 20, clForest, 17, clWater, 2, clBaseResource, 3),
  clForest
 );
 
 RMS.SetProgress(50);
 
 if (randBool())
 	createHills([tGrass, tCliff, tHill], avoidClasses(clPlayer, 20, clForest, 1, clHill, 15, clWater, 3), clHill, scaleByMapSize(3, 15));
 else
 	createMountains(tCliff, avoidClasses(clPlayer, 20, clForest, 1, clHill, 15, clWater, 3), clHill, scaleByMapSize(3, 15));
 
 log("Creating grass patches...");
 createLayeredPatches(
  [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
  [[tGrass,tGrassSand50],[tGrassSand50,tGrassSand25], [tGrassSand25,tGrass]],
  [1,1],
  avoidClasses(clForest, 0, clGrass, 2, clPlayer, 10, clWater, 2, clDirt, 2, clHill, 1)
 );
 
 RMS.SetProgress(55);
 
 log("Creating dirt patches...");
 createLayeredPatches(
  [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
  [tDirt3, tDirt2,[tDirt,tMainDirt], [tDirtCracks,tMainDirt]],
  [1,1,1],
  avoidClasses(clForest, 0, clDirt, 2, clPlayer, 10, clWater, 2, clGrass, 2, clHill, 1)
 );
 
 RMS.SetProgress(60);
 
 log("Creating stone mines...");
 createMines(
  [
   [new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)],
   [new SimpleObject(oStoneSmall, 2,5, 1,3)]
  ],
  avoidClasses(clForest, 1, clPlayer, 20, clRock, 10, clWater, 1, clHill, 1)
 );
 
 log("Creating metal mines...");
 createMines(
  [
   [new SimpleObject(oMetalLarge, 1,1, 0,4)]
  ],
  avoidClasses(clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clWater, 1, clHill, 1),
  clMetal
 );
 
 RMS.SetProgress(65);
 
 createDecoration
 (
  [[new SimpleObject(aDecorativeRock, 1,3, 0,1)],
   [new SimpleObject(aBush2, 1,2, 0,1), new SimpleObject(aBush1, 1,3, 0,2), new SimpleObject(aBush4, 1,2, 0,1), new SimpleObject(aBush3, 1,3, 0,2)]
  ],
  [
   scaleByMapSize(16, 262),
   scaleByMapSize(40, 360)
  ],
  avoidClasses(clWater, 2, clForest, 0, clPlayer, 0, clHill, 1)
 );
 
 RMS.SetProgress(70);
 
 createFood
 (
  [
   [new SimpleObject(oFish, 2,3, 0,2)]
  ],
  [
   3*scaleByMapSize(5,20)
  ],
  [avoidClasses(clFood, 10), stayClasses(clWater, 5)]
 );
 
 createFood
 (
  [
   [new SimpleObject(oSheep, 5,7, 0,4)],
   [new SimpleObject(oGoat, 2,4, 0,3)],
   [new SimpleObject(oDeer, 2,4, 0,2)]
  ],
  [
   scaleByMapSize(5,20),
   scaleByMapSize(5,20),
   scaleByMapSize(5,20)
  ],
  avoidClasses(clForest, 0, clPlayer, 8, clWater, 1, clFood, 10, clHill, 1)
 );
 
 createFood
 (
  [
   [new SimpleObject(oBerryBush, 5,7, 0,4)]
  ],
  [
   3 * numPlayers
  ],
  avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 10)
 );
 
 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);
 setWaterColor(0, 0.501961, 1);
 setWaterTint(0.501961, 1, 1);
 setWaterWaviness(2.5);
 setWaterType("ocean");
 setWaterMurkiness(0.49);
 
 setFogFactor(0.3);
 setFogThickness(0.25);
 
 setPPEffect("hdr");
 setPPContrast(0.62);
 setPPSaturation(0.51);
 setPPBloom(0.12);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/cycladic_archipelago.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/cycladic_archipelago.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/cycladic_archipelago.js	(revision 20301)
@@ -1,437 +1,424 @@
 RMS.LoadLibrary("rmgen");
 
 const tOceanRockDeep = "medit_sea_coral_deep";
 const tOceanCoral = "medit_sea_coral_plants";
 const tBeachWet = "medit_sand_wet";
 const tBeachDry = "medit_sand";
 const tBeach = ["medit_rocks_grass","medit_sand", "medit_rocks_grass_shrubs"];
 const tBeachBlend = ["medit_rocks_grass", "medit_rocks_grass_shrubs"];
 const tCity = "medit_city_tile";
 const tGrassDry = ["medit_grass_field_dry", "medit_grass_field_b"];
 const tGrass = ["medit_rocks_grass", "medit_rocks_grass","medit_dirt","medit_rocks_grass_shrubs"];
 const tGrassShrubs = "medit_shrubs";
 const tCliffShrubs = ["medit_cliff_aegean_shrubs", "medit_cliff_italia_grass","medit_cliff_italia"];
 const tCliff = ["medit_cliff_italia", "medit_cliff_italia", "medit_cliff_italia_grass"];
 const tForestFloor = "medit_forestfloor_a";
 
 const oBeech = "gaia/flora_tree_euro_beech";
 const oBerryBush = "gaia/flora_bush_berry";
 const oCarob = "gaia/flora_tree_carob";
 const oCypress1 = "gaia/flora_tree_cypress";
 const oCypress2 = "gaia/flora_tree_cypress";
 const oLombardyPoplar = "gaia/flora_tree_poplar_lombardy";
 const oPalm = "gaia/flora_tree_medit_fan_palm";
 const oPine = "gaia/flora_tree_aleppo_pine";
 const oDateT = "gaia/flora_tree_cretan_date_palm_tall";
 const oDateS = "gaia/flora_tree_cretan_date_palm_short";
 const oDeer = "gaia/fauna_deer";
 const oFish = "gaia/fauna_fish";
 const oWhale = "gaia/fauna_whale_humpback";
 const oStoneLarge = "gaia/geology_stonemine_medit_quarry";
 const oStoneSmall = "gaia/geology_stone_mediterranean";
 const oMetalLarge = "gaia/geology_metal_mediterranean_slabs";
 const oShipwreck = "other/special_treasure_shipwreck";
 const oShipDebris = "other/special_treasure_shipwreck_debris";
 
 const aRockLarge = "actor|geology/stone_granite_large.xml";
 const aRockMed = "actor|geology/stone_granite_med.xml";
 const aRockSmall = "actor|geology/stone_granite_small.xml";
 
 // terrain + entity (for painting)
 const pPalmForest = [tForestFloor+TERRAIN_SEPARATOR+oPalm, tGrass];
 const pPineForest = [tForestFloor+TERRAIN_SEPARATOR+oPine, tGrass];
 const pPoplarForest = [tForestFloor+TERRAIN_SEPARATOR+oLombardyPoplar, tGrass];
 const pMainForest = [tForestFloor+TERRAIN_SEPARATOR+oCarob, tForestFloor+TERRAIN_SEPARATOR+oBeech, tGrass, tGrass];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 
 var clCoral = createTileClass();
 var clPlayer = createTileClass();
 var clIsland = createTileClass();
 var clCity = createTileClass();
 var clDirt = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 
 var playerIDs = sortAllPlayers();
 
 //array holding starting islands based on number of players
 var startingPlaces=[[0],[0,3],[0,2,4],[0,1,3,4],[0,1,2,3,4],[0,1,2,3,4,5]];
 
 var startAngle = randFloat(0, 2 * Math.PI);
 var numIslands = Math.max(6, numPlayers);
 var islandX = [];
 var islandZ = [];
 
 var areas = [];
 
 var nPlayer = 0;
 var playerX = [];
 var playerZ = [];
 
 function createCycladicArchipelagoIsland(ix, iz, tileClass, radius, coralRadius)
 {
 	log("Creating deep ocean rocks...");
 	createArea(
 		new ClumpPlacer(Math.PI * Math.pow(radius + coralRadius, 2), 0.7, 0.1, 10, ix, iz),
 		[
 			new LayeredPainter([tOceanRockDeep, tOceanCoral], [5]),
 			paintClass(clCoral)
 		],
 		avoidClasses(clCoral, 0, clPlayer, 0));
 
 	log("Creating island...");
 	areas.push(
 		createArea(
 			new ClumpPlacer(Math.PI * Math.pow(radius, 2), 0.7, 0.1, 10, ix, iz),
 			[
 				new LayeredPainter([tOceanCoral, tBeachWet, tBeachDry, tBeach, tBeachBlend, tGrass], [1, 3, 1, 1, 2]),
 				new SmoothElevationPainter(ELEVATION_SET, 3, 5),
 				paintClass(tileClass)
 			],
 			avoidClasses(clPlayer, 0)));
 }
 
 log("Creating player islands...");
 for (let i = 0; i < numIslands; ++i)
 {
 	let angle = startAngle + i * 2 * Math.PI / numIslands;
 	islandX[i] = 0.5 + 0.39 * Math.cos(angle);
 	islandZ[i] = 0.5 + 0.39 * Math.sin(angle);
 
 	// Determine which player resides on this island
 	let isPlayerIsland = numPlayers >= 6 || i == startingPlaces[numPlayers - 1][nPlayer];
 	if (isPlayerIsland)
 	{
 		[playerX[nPlayer], playerZ[nPlayer]] = [islandX[i], islandZ[i]];
 		++nPlayer;
 	}
 
 	createCycladicArchipelagoIsland(
 		Math.round(fractionToTiles(islandX[i])),
 		Math.round(fractionToTiles(islandZ[i])),
 		isPlayerIsland ? clPlayer : clIsland,
 		scaleByMapSize(15, 40),
 		scaleByMapSize(1, 5));
 }
 
 log("Creating central islands...");
 var nCenter = Math.floor(scaleByMapSize(1, 4));
 for (let i = 0; i < nCenter; ++i)
 {
 	let radius = randFloat(0.1, 0.16);
 	let angle = startAngle + Math.PI * (i * 2 / nCenter + randFloat(-1, 1) / 8);
 
 	createCycladicArchipelagoIsland(
 		Math.round(fractionToTiles(0.5 + radius * Math.cos(angle))),
 		Math.round(fractionToTiles(0.5 + radius * Math.sin(angle))),
 		clIsland,
 		scaleByMapSize(15, 30),
 		2);
 }
 
 for (let i = 0; i < numPlayers; ++i)
 {
 	let fx = fractionToTiles(playerX[i]);
 	let fz = fractionToTiles(playerZ[i]);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 10;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oBerryBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 		mAngle = randFloat(0, TWO_PI);
 
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var num = 2;
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(12, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oPalm, num, num, 0,3)],
 		false, clBaseResource, tX, tZ
 	);
 	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])
 	{
 		var id = playerIDs[nPlayer];
 
 		// Get the x and z in tiles
 		var fx = fractionToTiles(islandX[i]);
 		var fz = fractionToTiles(islandZ[i]);
 		var ix = round(fx);
 		var iz = round(fz);
 
 		// Create city patch
 		var cityRadius = 6;
 		var placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 		var painter = new LayeredPainter([tGrass, tCity], [1]);
 		createArea(placer, [painter,paintClass(clCity)], null);
 
 		placeCivDefaultEntities(fx, fz, id, { 'iberWall': 'towers' });
 
 		++nPlayer;
 	}
 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...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
 createObjectGroupsByAreasDeprecated(group, 0,
 	[avoidClasses(clWater, 1, clForest, 1, clHill, 1, clPlayer, 5, clRock, 6)],
 	scaleByMapSize(4,16), 200, areas
 );
 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
 );
 RMS.SetProgress(50);
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroupsByAreasDeprecated(group, 0,
 	[avoidClasses(clWater, 1, clForest, 1, clHill, 1, clPlayer, 5, clMetal, 6, clRock, 6)],
 	scaleByMapSize(4,16), 200, areas
 );
 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...");
 for (let tree of [oCarob, oBeech, oLombardyPoplar, oLombardyPoplar, oPine])
 	createObjectGroupsByAreasDeprecated(
 		new SimpleGroup([new SimpleObject(tree, 1,1, 0,1)], true, clForest),
 		0,
 		avoidClasses(clWater, 2, clForest, 2, clCity, 3, clBaseResource, 4, clRock, 6, clMetal, 6, clPlayer, 1, clHill, 1),
 		scaleByMapSize(2, 38), 50, areas
 	);
 RMS.SetProgress(66);
 
 log("Create straggler cypresses...");
 group = new SimpleGroup(
 	[new SimpleObject(oCypress2, 1,3, 0,3), new SimpleObject(oCypress1, 0,2, 0,2)],
 	true
 );
 createObjectGroupsByAreasDeprecated(group, 0,
 	avoidClasses(clWater, 2, clForest, 2, clCity, 3, clBaseResource, 4, clRock, 6, clMetal, 6, clPlayer, 1, clHill, 1),
 	scaleByMapSize(5, 75), 50, areas
 );
 RMS.SetProgress(70);
 
 log("Create straggler date palms...");
 group = new SimpleGroup(
 	[new SimpleObject(oDateS, 1,3, 0,3), new SimpleObject(oDateT, 0,2, 0,2)],
 	true
 );
 createObjectGroupsByAreasDeprecated(group, 0,
 	avoidClasses(clWater, 2, clForest, 1, clCity, 0, clBaseResource, 4, clRock, 6, clMetal, 6, clPlayer, 1, clHill, 1),
 	scaleByMapSize(5, 75), 50, areas
 );
 RMS.SetProgress(74);
 
 log("Creating rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockSmall, 0,3, 0,2), new SimpleObject(aRockMed, 0,2, 0,2),
 	new SimpleObject(aRockLarge, 0,1, 0,2)]
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 0, clCity, 0),
 	scaleByMapSize(30, 180), 50
 );
 RMS.SetProgress(78);
 
 log("Creating deer...");
 group = new SimpleGroup(
 	[new SimpleObject(oDeer, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 5, clForest, 1, clHill, 1, clCity, 10, clMetal, 6, clRock, 2, clFood, 8),
 	3 * numPlayers, 50
 );
 RMS.SetProgress(82);
 
 log("Creating berry bushes...");
 group = new SimpleGroup([new SimpleObject(oBerryBush, 5,7, 0,3)], true, clFood);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 2, clForest, 1, clHill, 1, clCity, 10, clMetal, 6, clRock, 2, clFood, 8),
 	1.5 * numPlayers, 100
 );
 RMS.SetProgress(86);
 
 log("Creating Fish...");
 group = new SimpleGroup([new SimpleObject(oFish, 1,1, 0,3)], true, clFood);
 createObjectGroupsDeprecated(group, 0,
 	[stayClasses(clWater,1),avoidClasses(clFood, 8)],
 	scaleByMapSize(40,200), 100
 );
 RMS.SetProgress(90);
 
 log("Creating Whales...");
 group = new SimpleGroup([new SimpleObject(oWhale, 1,1, 0,3)], true, clFood);
 createObjectGroupsDeprecated(group, 0,
 	[stayClasses(clWater,1),avoidClasses(clFood, 8, clPlayer,4,clIsland,4)],
 	scaleByMapSize(10,40), 100
 );
 RMS.SetProgress(94);
 
 log("Creating shipwrecks...");
 group = new SimpleGroup([new SimpleObject(oShipwreck, 1,1, 0,3)], true, clFood);
 createObjectGroupsDeprecated(group, 0,
 	[stayClasses(clWater,1),avoidClasses(clFood, 8)],
 	scaleByMapSize(6,16), 100
 );
 RMS.SetProgress(98);
 
 log("Creating shipwreck debris...");
 group = new SimpleGroup([new SimpleObject(oShipDebris, 1,2, 0,4)], true, clFood);
 createObjectGroupsDeprecated(group, 0,
 	[stayClasses(clWater,1),avoidClasses(clFood, 8)],
 	scaleByMapSize(10,20), 100
 );
 RMS.SetProgress(99);
 
 setSkySet("sunny");
 setWaterColor(0.2,0.294,0.49);
 setWaterTint(0.208, 0.659, 0.925);
 setWaterMurkiness(0.72);
 setWaterWaviness(3.0);
 setWaterType("ocean");
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/english_channel.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/english_channel.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/english_channel.js	(revision 20301)
@@ -1,347 +1,375 @@
 RMS.LoadLibrary("rmgen");
 
 const tGrass = ["temp_grass", "temp_grass", "temp_grass_d"];
 const tGrassDForest = "temp_plants_bog";
 const tGrassA = "temp_grass_plants";
 const tGrassB = "temp_plants_bog";
 const tGrassC = "temp_mud_a";
 const tHill = ["temp_highlands", "temp_grass_long_b"];
 const tCliff = ["temp_cliff_a", "temp_cliff_b"];
 const tRoad = "temp_road";
 const tRoadWild = "temp_road_overgrown";
 const tGrassPatchBlend = "temp_grass_long_b";
 const tGrassPatch = ["temp_grass_d", "temp_grass_clovers"];
 const tShore = "temp_dirt_gravel";
 const tWater = "temp_dirt_gravel_b";
 
 const oBeech = "gaia/flora_tree_euro_beech";
 const oPoplar = "gaia/flora_tree_poplar";
 const oApple = "gaia/flora_tree_apple";
 const oOak = "gaia/flora_tree_oak";
 const oBerryBush = "gaia/flora_bush_berry";
 const oDeer = "gaia/fauna_deer";
 const oFish = "gaia/fauna_fish";
 const oGoat = "gaia/fauna_goat";
 const oBoar = "gaia/fauna_boar";
 const oStoneLarge = "gaia/geology_stonemine_temperate_quarry";
 const oStoneSmall = "gaia/geology_stone_temperate";
 const oMetalLarge = "gaia/geology_metal_temperate_slabs";
 
 const aGrass = "actor|props/flora/grass_soft_large_tall.xml";
 const aGrassShort = "actor|props/flora/grass_soft_large.xml";
 const aRockLarge = "actor|geology/stone_granite_large.xml";
 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";
 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();
 
 const numPlayers = getNumPlayers();
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clShallow = createTileClass();
 
 var playerIDs = primeSortAllPlayers();
 var playerPos = placePlayersRiver();
 
 var playerX = [];
 var playerZ = [];
 
 for (var i = 0; i < numPlayers; i++)
 {
 	playerZ[i] = 0.2 + 0.6*(i%2);
 	playerX[i] = playerPos[i];
 }
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 	// Setting tile class
 	addCivicCenterAreaToClass(ix, iz, clPlayer);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	var placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tRoadWild, tRoad], [1]);
 	createArea(placer, [painter, paintClass(clPlayer)], null);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oBerryBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 		mAngle = randFloat(0, TWO_PI);
 
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var num = 2;
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(11, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oOak, num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 RMS.SetProgress(10);
 
 paintRiver({
 	"horizontal": true,
 	"parallel": false,
 	"position": 0.5,
 	"width": 0.25,
 	"fadeDist": 0.01,
 	"deviation": 0,
 	"waterHeight": -4,
 	"landHeight": 3,
 	"meanderShort": 20,
 	"meanderLong": 0,
 	"waterFunc": (ix, iz, height) => {
 		placeTerrain(ix, iz, height < -1.5 ? tWater : tShore);
 	},
 	"landFunc": (ix, iz, shoreDist1, shoreDist2) => {
 		setHeight(ix, iz, 3.1);
 	}
 });
 
 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);
 
 	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);
 paintTileClassBasedOnHeight(-6, 0.5, 1, clWater);
 RMS.SetProgress(25);
 
 createBumps(avoidClasses(clWater, 5, clPlayer, 20));
 RMS.SetProgress(30);
 
 createHills([tCliff, tCliff, tHill], avoidClasses(clPlayer, 20, clHill, 15, clWater, 5), clHill, scaleByMapSize(1, 4) * numPlayers);
 RMS.SetProgress(50);
 
 createForests(
  [tGrass, tGrassDForest, tGrassDForest, pForestD, pForestD],
  avoidClasses(clPlayer, 20, clForest, 17, clHill, 0, clWater, 6),
  clForest,
  1.0
 );
 RMS.SetProgress(70);
 
 log("Creating dirt patches...");
 createLayeredPatches(
  [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
  [[tGrass,tGrassA], tGrassB, [tGrassB,tGrassC]],
  [1,1],
  avoidClasses(clWater, 1, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 6)
 );
 
 log("Creating grass patches...");
 createPatches(
  [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
  [tGrassPatchBlend, tGrassPatch],
  [1],
  avoidClasses(clWater, 1, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 6)
 );
 RMS.SetProgress(80);
 
 log("Creating stone mines...");
 createMines(
  [
   [new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)],
   [new SimpleObject(oStoneSmall, 2,5, 1,3)]
  ],
  avoidClasses(clWater, 2, clForest, 1, clPlayer, 20, clRock, 10, clHill, 2)
 );
 
 log("Creating metal mines...");
 createMines(
  [
   [new SimpleObject(oMetalLarge, 1,1, 0,4)]
  ],
  avoidClasses(clWater, 2, clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 2),
  clMetal
 );
 RMS.SetProgress(85);
 
 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),
   scaleByMapSize(13, 200),
   scaleByMapSize(13, 200),
   scaleByMapSize(13, 200)
  ],
  avoidClasses(clWater, 1, clForest, 0, clPlayer, 0, clHill, 0)
 );
 
 // create water decoration in the shallow parts
 createDecoration
 (
  [[new SimpleObject(aReeds, 1,3, 0,1)],
   [new SimpleObject(aLillies, 1,2, 0,1)]
  ],
  [
   scaleByMapSize(800, 12800),
   scaleByMapSize(800, 12800)
  ],
  stayClasses(clShallow, 0)
 );
 
 createFood
 (
  [
   [new SimpleObject(oDeer, 5,7, 0,4)],
   [new SimpleObject(oGoat, 2,3, 0,2)],
   [new SimpleObject(oBoar, 2,3, 0,2)]
  ],
  [
   3 * numPlayers,
   3 * numPlayers,
   3 * numPlayers
  ],
  avoidClasses(clWater, 1, clForest, 0, clPlayer, 20, clHill, 0, clFood, 15)
 );
 
 createFood
 (
  [
   [new SimpleObject(oBerryBush, 5,7, 0,4)]
  ],
  [
   randIntInclusive(1, 4) * numPlayers + 2
  ],
  avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 10)
 );
 
 createFood
 (
  [
   [new SimpleObject(oFish, 2,3, 0,2)]
  ],
  [scaleByMapSize(3, 25) * numPlayers],
  [avoidClasses(clFood, 6), stayClasses(clWater, 4)]
 );
 
 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);
 setWaterTint(0.255, 0.361, 0.651);
 setWaterWaviness(3.0);
 setWaterType("ocean");
 setWaterMurkiness(0.83);
 
 setFogThickness(0.35);
 setFogFactor(0.55);
 
 setPPEffect("hdr");
 setPPSaturation(0.62);
 setPPContrast(0.62);
 setPPBloom(0.37);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/extinct_volcano.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/extinct_volcano.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/extinct_volcano.js	(revision 20301)
@@ -1,511 +1,511 @@
 RMS.LoadLibrary("rmgen");
 
 const tHillDark = "cliff volcanic light";
 const tHillMedium1 = "ocean_rock_a";
 const tHillMedium2 = "ocean_rock_b";
 const tHillVeryDark = ["cliff volcanic coarse", "cave_walls"];
 const tRoad = "road1";
 const tRoadWild = "road1";
 const tForestFloor1 = tHillMedium1;
 const tForestFloor2 = tHillMedium2;
 const tGrassA = "cliff volcanic light";
 const tGrassB = "ocean_rock_a";
 const tGrassPatchBlend = "temp_grass_long_b";
 const tGrassPatch = ["temp_grass_d", "temp_grass_clovers"];
 const tShoreBlend = "cliff volcanic light";
 const tShore = "ocean_rock_a";
 const tWater = "ocean_rock_b";
 
 // Gaia entities
 const oTree = "gaia/flora_tree_dead";
 const oTree2 = "gaia/flora_tree_euro_beech";
 const oTree3 = "gaia/flora_tree_oak";
 const oTree4 = "gaia/flora_tree_oak_dead";
 const oBush = "gaia/flora_bush_temperate";
 const oFruitBush = "gaia/flora_bush_berry";
 const oRabbit = "gaia/fauna_rabbit";
 const oGoat = "gaia/fauna_goat";
 const oBear = "gaia/fauna_bear";
 const oStoneLarge = "gaia/geology_stonemine_temperate_quarry";
 const oStoneSmall = "gaia/geology_stone_temperate";
 const oMetalLarge = "gaia/geology_metal_temperate_slabs";
 const oTower = "other/palisades_rocks_fort";
 
 // Decorative props
 const aRockLarge = "actor|geology/stone_granite_med.xml";
 const aRockMedium = "actor|geology/stone_granite_med.xml";
 const aBushMedium = "actor|props/flora/bush_tempe_me.xml";
 const aBushSmall = "actor|props/flora/bush_tempe_sm.xml";
 const aGrass = "actor|props/flora/grass_soft_large_tall.xml";
 const aGrassShort = "actor|props/flora/grass_soft_large.xml";
 const aRain = "actor|particle/rain_shower.xml";
 
 const pForestD = [
 	tForestFloor1 + TERRAIN_SEPARATOR + oTree,
 	tForestFloor2 + TERRAIN_SEPARATOR + oTree2,
 	tForestFloor1
 ];
 
 const pForestP = [
 	tForestFloor1 + TERRAIN_SEPARATOR + oTree3,
 	tForestFloor2 + TERRAIN_SEPARATOR + oTree4,
 	tForestFloor1
 ];
 
 InitMap();
 
 var P_FOREST = 0.7;
 var totalTrees = scaleByMapSize(1200, 3000);
 var numForest = totalTrees * P_FOREST;
 var numStragglers = totalTrees * (1.0 - P_FOREST);
 
 var numPlayers = getNumPlayers();
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clFood = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clGrass = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clBaseResource = createTileClass();
 var clBumps = createTileClass();
 var clTower = createTileClass();
 var clRain = createTileClass();
 
 var ccMountainHeight = 25;
 
 var [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 for (let i = 0; i < numPlayers; ++i)
 {
 	let id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 	let radius = scaleByMapSize(15, 25);
 
 	let fx = fractionToTiles(playerX[i]);
 	let fz = fractionToTiles(playerZ[i]);
 	let ix = Math.round(fx);
 	let iz = Math.round(fz);
 
 	// This one consists of many bumps, creating an omnidirectional ramp
 	createMountain(
 		ccMountainHeight,
 		Math.floor(scaleByMapSize(15, 15)),
 		Math.floor(scaleByMapSize(15, 15)),
 		Math.floor(scaleByMapSize(4, 10)),
 		avoidClasses(),
 		ix,
 		iz,
 		tHillDark,
 		clPlayer,
 		14);
 
 	// Flatten the initial CC area
 	let hillSize = PI * radius * radius;
 	createArea(
 		new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz),
 		[
 			new LayeredPainter([tHillVeryDark, tHillMedium1], [radius]),
 			new SmoothElevationPainter(ELEVATION_SET, ccMountainHeight, radius),
 			paintClass(clPlayer)
 		],
 		null);
 
 	// Create the city patch
 	let cityRadius = radius / 3;
 	createArea(
 		new ClumpPlacer(PI * cityRadius * cityRadius, 0.6, 0.3, 10, ix, iz),
 		new LayeredPainter([tRoadWild, tRoad], [1]),
 		null);
 
 	placeCivDefaultEntities(fx, fz, id, { 'iberWall': 'towers' });
 
 	// Create metal mine
 	let mAngle = randFloat(0, 2 * PI);
 	let mDist = 12;
 	createObjectGroup(
 		new SimpleGroup(
 			[new SimpleObject(oMetalLarge, 1, 1, 0, 0)],
 			true,
 			clBaseResource,
 			Math.round(fx + mDist * Math.cos(mAngle)),
 			Math.round(fz + mDist * Math.sin(mAngle))),
 		0);
 
 	// Create stone mines
 	mAngle += randFloat(PI/4, PI/3);
 	createObjectGroup(
 		new SimpleGroup(
 			[new SimpleObject(oStoneLarge, 1, 1, 0, 2)],
 			true,
 			clBaseResource,
 			Math.round(fx + mDist * Math.cos(mAngle)),
 			Math.round(fz + mDist * Math.sin(mAngle))),
 		0);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// Create berry bushes
 	mAngle += randFloat(PI/4, PI/2);
 	let bbDist = 12;
 	createObjectGroup(
 		new SimpleGroup(
 			[new SimpleObject(oFruitBush, 5, 5, 0, 3)],
 			true,
 			clBaseResource,
 			Math.round(fx + bbDist * Math.cos(mAngle)),
 			Math.round(fz + bbDist * Math.sin(mAngle))),
 		0);
 
 	// Create starting trees
 	let num = Math.floor(hillSize / 60);
 	let tries = 20;
 	for (let x = 0; x < tries; ++x)
 	{
 		let tAngle = randFloat(0, 2 * PI);
 		let tDist = randFloat(10, 12);
 		if (createObjectGroup(
 			new SimpleGroup(
 				[new SimpleObject(oTree2, num, num, 0, 3)],
 				false,
 				clBaseResource,
 				Math.round(fx + tDist * Math.cos(tAngle)),
 				Math.round(fz + tDist * Math.sin(tAngle))),
 			0,
 			avoidClasses(clBaseResource, 3)))
 		{
 			break;
 		}
 	}
 }
 RMS.SetProgress(15);
 
 createVolcano(0.5, 0.5, clHill, tHillVeryDark, undefined, false, ELEVATION_SET);
 RMS.SetProgress(20);
 
 log("Creating lakes...");
 createAreas(
 	new ChainPlacer(5, 6, Math.floor(scaleByMapSize(10, 14)), 0.1),
 	[
 		new LayeredPainter([tShoreBlend, tShore, tWater], [1, 1]),
 		new SmoothElevationPainter(ELEVATION_SET, -4, 3),
 		paintClass(clWater)
 	],
 	avoidClasses(clPlayer, 0, clHill, 2, clWater, 12),
 	Math.round(scaleByMapSize(6, 12)));
 RMS.SetProgress(25);
 
 createBumps(avoidClasses(clPlayer, 0, clHill, 0), scaleByMapSize(50, 300), 1, 10, 3, 0, scaleByMapSize(4, 10));
 paintTileClassBasedOnHeight(10, 100, 0, clBumps);
 RMS.SetProgress(30);
 
 log("Creating hills...");
 createAreas(
 	new ClumpPlacer(scaleByMapSize(20, 150), 0.2, 0.1, 1),
 	[
 		new LayeredPainter([tHillDark, tHillDark, tHillDark], [2, 2]),
 		new SmoothElevationPainter(ELEVATION_SET, 18, 2),
 		paintClass(clHill)
 	],
 	avoidClasses(clPlayer, 0, clHill, 15, clWater, 2, clBaseResource, 2),
 	scaleByMapSize(2, 8) * numPlayers);
 RMS.SetProgress(35);
 
 log("Creating forests...");
 var types = [
 	[[tGrassB, tGrassA, pForestD], [tGrassB, pForestD]],
 	[[tGrassB, tGrassA, pForestP], [tGrassB, pForestP]]
 ];
 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(
 			clPlayer, 4,
 			clForest, 10,
 			clHill, 0,
 			clWater, 2),
 		num);
 RMS.SetProgress(40);
 
 log("Creating hill patches...");
 for (let size of [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)])
 	for (let type of [[tHillMedium1, tHillDark], [tHillDark, tHillMedium2], [tHillMedium1, tHillMedium2]])
 		createAreas(
 			new ClumpPlacer(size, 0.3, 0.06, 0.5),
 			[
 				new LayeredPainter(type, [1]),
 				paintClass(clGrass)
 			],
 			avoidClasses(
 				clWater, 3,
 				clForest, 0,
 				clHill, 0,
 				clBumps, 0,
 				clPlayer, 0),
 			scaleByMapSize(20, 80));
 RMS.SetProgress(45);
 
 log("Creating grass patches...");
 createLayeredPatches(
 	[scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
 	[tGrassPatchBlend, tGrassPatch],
 	[1],
 	avoidClasses(
 		clWater, 1,
 		clForest, 0,
 		clHill, 0,
 		clGrass, 5,
 		clBumps, 0,
 		clPlayer, 0),
 	clDirt);
 RMS.SetProgress(50);
 
 log("Creating stone mines...");
 createObjectGroupsDeprecated(
 	new SimpleGroup(
 		[
 			new SimpleObject(oStoneSmall, 0, 2, 0, 4),
 			new SimpleObject(oStoneLarge, 1, 1, 0, 4)
 		],
 		true,
 		clRock),
 	0,
 	[
 		stayClasses(clBumps, 1),
 		avoidClasses(
 			clWater, 3,
 			clForest, 1,
 			clPlayer, 0,
 			clRock, 15,
 			clHill, 0)
 	],
 	100,
 	100);
 RMS.SetProgress(55);
 
 log("Creating small stone quarries...");
 createObjectGroupsDeprecated(
 	new SimpleGroup([new SimpleObject(oStoneSmall, 2, 5, 1, 3)], true, clRock),
 	0,
 	[
 		stayClasses(clBumps, 1),
 		avoidClasses(
 			clWater, 3,
 			clForest, 1,
 			clPlayer, 0,
 			clRock, 15,
 			clHill, 0)
 	],
 	100,
 	100);
 RMS.SetProgress(60);
 
 log("Creating metal mines...");
 createObjectGroupsDeprecated(
 	new SimpleGroup([new SimpleObject(oMetalLarge, 1, 1, 0, 4)], true, clMetal),
 	0,
 	[
 		stayClasses(clBumps, 1),
 		avoidClasses(
 			clWater, 3,
 			clForest, 1,
 			clPlayer, 0,
 			clMetal, 15,
 			clRock, 10,
 			clHill, 0)
 	],
 	100,
 	100);
 RMS.SetProgress(65);
 
 log("Creating towers...");
 createObjectGroupsDeprecated(
 	new SimpleGroup([new SimpleObject(oTower, 1, 1, 0, 4)], true, clTower),
 	0,
 	[
 		stayClasses(clBumps, 3),
 		avoidClasses(
 			clMetal, 5,
 			clRock, 5,
 			clHill, 0,
 			clTower, 60,
 			clPlayer, 10,
 			clForest, 2)
 	],
 	500,
 	1);
 RMS.SetProgress(67);
 
 createDecoration(
 		[
 			[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(15, 200),
 			scaleByMapSize(15, 200),
 			scaleByMapSize(15, 200)
 		],
 		[
 			stayClasses(clGrass, 0),
 			avoidClasses(
 				clWater, 0,
 				clForest, 0,
 				clPlayer, 0,
 				clHill, 0)
 		]);
 RMS.SetProgress(70);
 
 createDecoration(
 		[
 			[
 				new SimpleObject(aRockMedium, 1, 3, 0, 1)
 			],
 			[
 				new SimpleObject(aRockLarge, 1, 2, 0, 1),
 				new SimpleObject(aRockMedium, 1, 3, 0, 2)
 			]
 		],
 		[
 			scaleByMapSize(15, 250),
 			scaleByMapSize(15, 150)
 		],
 		avoidClasses(
 			clWater, 0,
 			clForest, 0,
 			clPlayer, 0,
 			clHill, 0
 		));
 RMS.SetProgress(75);
 
 createFood(
 	[
 		[new SimpleObject(oRabbit, 5, 7, 2, 4)],
 		[new SimpleObject(oGoat, 3, 5, 2, 4)]
 	],
 	[
 		scaleByMapSize(1, 6) * numPlayers,
 		scaleByMapSize(3, 10) * numPlayers
 	],
 	[
 		avoidClasses(
 			clWater, 1,
 			clForest, 0,
 			clPlayer, 0,
 			clHill, 1,
 			clFood, 20)
 	],
 	clFood);
 RMS.SetProgress(78);
 
 createFood(
 	[
 		[new SimpleObject(oBear, 1, 1, 0, 2)]
 	],
 	[
 		3 * numPlayers
 	],
 	[
 		avoidClasses(
 			clWater, 1,
 			clForest, 0,
 			clPlayer, 0,
 			clHill, 1,
 			clFood, 20
 		),
 		stayClasses(clForest, 2)
 	],
 	clFood);
 RMS.SetProgress(81);
 
 createFood(
 	[
 		[new SimpleObject(oFruitBush, 1, 2, 0, 4)]
 	],
 	[
 		3 * numPlayers
 	],
 	[stayClasses(clGrass, 1), avoidClasses(clWater, 1, clForest, 0, clPlayer, 0, clHill, 1, clFood, 10)],
 	clFood);
 RMS.SetProgress(85);
 
 log("Creating straggler trees and bushes...");
 var types = [oTree, oTree2, oTree3, oTree4, oBush];
 var num = Math.floor(numStragglers / types.length);
 for (let type of types)
 	createObjectGroupsDeprecated(
 		new SimpleGroup(
 			[new SimpleObject(type, 1, 1, 0, 3)],
 			true,
 			clForest),
 		0,
 		[
 			stayClasses(clGrass, 1),
 			avoidClasses(
 				clWater, 5,
 				clForest, 1,
 				clHill, 1,
 				clPlayer, 0,
 				clMetal, 1,
 				clRock, 1)
 		],
 		num);
 RMS.SetProgress(90);
 
 log("Creating straggler bushes...");
 createObjectGroupsDeprecated(
 	new SimpleGroup(
 		[new SimpleObject(oBush, 1, 3, 0, 3)],
 		true,
 		clForest
 	),
 	0,
 	[
 		stayClasses(clGrass, 3),
 		avoidClasses(
 			clWater, 1,
 			clForest, 1,
 			clPlayer, 0,
 			clMetal, 1,
 			clRock, 1)
 	],
 	numStragglers);
 RMS.SetProgress(95);
 
 log("Creating rain drops...");
 createObjectGroupsDeprecated(
 	new SimpleGroup(
 		[new SimpleObject(aRain, 2, 2, 1, 4)],
 		true,
 		clRain),
 	0,
 	avoidClasses(clRain, 5),
 	scaleByMapSize(80, 250));
 RMS.SetProgress(95);
 
 setSkySet("rain");
 setWaterType("lake");
 setWaterWaviness(2);
 setWaterColor(0.1, 0.13, 0.15);
 setWaterTint(0.058, 0.05, 0.035);
 setWaterMurkiness(0.9);
 
 setPPEffect("hdr");
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/flood.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/flood.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/flood.js	(revision 20301)
@@ -1,395 +1,381 @@
 RMS.LoadLibrary("rmgen");
 RMS.LoadLibrary("rmbiome");
 
 setSelectedBiome();
 
 const tMainTerrain = g_Terrains.mainTerrain;
 const tForestFloor1 = g_Terrains.forestFloor1;
 const tForestFloor2 = g_Terrains.forestFloor2;
 const tCliff = g_Terrains.cliff;
 const tTier1Terrain = g_Terrains.tier1Terrain;
 const tTier2Terrain = g_Terrains.tier2Terrain;
 const tTier3Terrain = g_Terrains.tier3Terrain;
 const tRoad = g_Terrains.road;
 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;
 const oTree4 = g_Gaia.tree4;
 const oTree5 = g_Gaia.tree5;
 const oFruitBush = g_Gaia.fruitBush;
 const oMainHuntableAnimal = g_Gaia.mainHuntableAnimal;
 const oFish = g_Gaia.fish;
 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;
 const aRockMedium = g_Decoratives.rockMedium;
 const aBushMedium = g_Decoratives.bushMedium;
 const aBushSmall = g_Decoratives.bushSmall;
 
 const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
 const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
 
 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);
 
-var [playerIDs, playerX, playerZ] = radialPlayerPlacement(0.38);
+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));
 
-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));
+var [playerIDs, playerX, playerZ] = radialPlayerPlacement(0.38);
 
+log("Creating player islands...")
 for (let i = 0; i < numPlayers; ++i)
 {
 	let id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	// Get the x and z in tiles
 	let fx = fractionToTiles(playerX[i]);
 	let fz = fractionToTiles(playerZ[i]);
 	let ix = round(fx);
 	let iz = round(fz);
 
 	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);
 
 	placeCivDefaultEntities(fx, fz, id, { "iberWall": false });
 
 	// 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);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// Create berry bushes
 	let bbAngle = randFloat(0, TWO_PI);
 	let bbDist = 12;
 	let bbX = round(fx + bbDist * cos(bbAngle));
 	let bbZ = round(fz + bbDist * sin(bbAngle));
 	let group = new SimpleGroup(
 		[new SimpleObject(oFruitBush, 5, 5, 0, 3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// Create metal mine
 	let mAngle = bbAngle;
 	while (abs(mAngle - bbAngle) < PI/3)
 		mAngle = randFloat(0, TWO_PI);
 
 	let mDist = 12;
 	let mX = round(fx + mDist * cos(mAngle));
 	let mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1, 1, 0, 0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// Create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1, 1, 0, 2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// Create starting trees, should avoid mines and bushes
 	let tries = 50;
 	let tDist = 16;
 	let num = 50;
 	for (let x = 0; x < tries; ++x)
 	{
 		let tAngle = randFloat(0, TWO_PI);
 		let tX = round(fx + tDist * cos(tAngle));
 		let tZ = round(fz + tDist * sin(tAngle));
 		group = new SimpleGroup(
 			[new SimpleObject(oTree2, num, num, 0, 7)],
 			true, clBaseResource, tX, tZ
 		);
 		if (createObjectGroup(group, 0, avoidClasses(clBaseResource, 5)))
 			break;
 	}
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 
 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));
-
-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)),
+log("Creating central island...");
+createArea(
+	new ChainPlacer(
+		6,
+		Math.floor(scaleByMapSize(10, 15)),
+		Math.floor(scaleByMapSize(200, 300)),
 		1,
-		randIntExclusive(0, mapSize),
-		randIntExclusive(0, mapSize),
+		centerOfMap,
+		centerOfMap,
 		0,
-		[Math.floor(mapSize * 0.01)]);
+		[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 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],
 	[avoidClasses(clPlayer, 25, clForest, 10, clBaseResource, 3, clMetal, 6, clRock, 3, clMountain, 2), stayClasses(clHill, 6)],
 	clForest,
 	0.7,
 	...rBiomeTreeCount(0.7));
 
 log("Creating straggeler trees...");
 let types = [oTree1, oTree2, oTree4, oTree3];
 createStragglerTrees(types, [avoidClasses(clBaseResource, 2, clMetal, 6, clRock, 3, clMountain, 2, clPlayer, 25), stayClasses(clHill, 6)]);
 
 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(
 	[
 		[new SimpleObject(oMainHuntableAnimal, 5, 7, 0, 4)],
 		[new SimpleObject(oSecondaryHuntableAnimal, 2, 3, 0, 2)]
 	],
 	[3 * numPlayers, 3 * numPlayers],
 	[avoidClasses(clForest, 0, clPlayer, 20, clMountain, 1, clFood, 4, clRock, 6, clMetal, 6), stayClasses(clHill, 2)]
 );
 
 RMS.SetProgress(75);
 
 createFood(
 	[
 		[new SimpleObject(oFruitBush, 5, 7, 0, 4)]
 	],
 	[3 * numPlayers],
 	[avoidClasses(clForest, 0, clPlayer, 15, clMountain, 1, clFood, 4, clRock, 6, clMetal, 6), stayClasses(clHill, 2)]
 );
 
 RMS.SetProgress(85);
 
 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)],
 		[new SimpleObject(aGrassShort, 2, 15, 0, 1, -PI/8, PI/8)],
 		[new SimpleObject(aGrass, 2, 10, 0, 1.8, -PI/8, PI/8), new SimpleObject(aGrassShort, 3, 10, 1.2, 2.5, -PI/8, PI/8)],
 		[new SimpleObject(aBushMedium, 1, 5, 0, 2), new SimpleObject(aBushSmall, 2, 4, 0, 2)]
 	],
 	[
 		scaleByMapSize(16, 262),
 		scaleByMapSize(8, 131),
 		planetm * scaleByMapSize(13, 200),
 		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(
 	[tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
 	avoidClasses(clPlayer, 30, clHill, 10, clFood, 5),
 	clForest,
 	0.1,
 	...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);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/fortress.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/fortress.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/fortress.js	(revision 20301)
@@ -1,344 +1,336 @@
 RMS.LoadLibrary("rmgen");
 
 const tGrass = ["temp_grass_aut", "temp_grass_aut", "temp_grass_d_aut"];
 const tForestFloor = "temp_grass_aut";
 const tGrassA = "temp_grass_plants_aut";
 const tGrassB = "temp_grass_b_aut";
 const tGrassC = "temp_grass_c_aut";
 const tHill = ["temp_highlands_aut", "temp_grass_long_b_aut"];
 const tCliff = ["temp_cliff_a", "temp_cliff_b"];
 const tRoad = "temp_road_aut";
 const tGrassPatch = "temp_grass_plants_aut";
 const tShore = "temp_plants_bog_aut";
 const tWater = "temp_mud_a";
 
 const oBeech = "gaia/flora_tree_euro_beech_aut";
 const oOak = "gaia/flora_tree_oak_aut";
 const oPine = "gaia/flora_tree_pine";
 const oDeer = "gaia/fauna_deer";
 const oFish = "gaia/fauna_fish";
 const oSheep = "gaia/fauna_rabbit";
 const oBerryBush = "gaia/flora_bush_berry";
 const oStoneLarge = "gaia/geology_stonemine_temperate_quarry";
 const oStoneSmall = "gaia/geology_stone_temperate";
 const oMetalLarge = "gaia/geology_metal_temperate_slabs";
 const oWood = "gaia/special_treasure_wood";
 const oFood = "gaia/special_treasure_food_bin";
 const oMetal = "gaia/special_treasure_metal";
 const oStone = "gaia/special_treasure_stone";
 
 const aGrass = "actor|props/flora/grass_soft_dry_small_tall.xml";
 const aGrassShort = "actor|props/flora/grass_soft_dry_large.xml";
 const aRockLarge = "actor|geology/stone_granite_med.xml";
 const aRockMedium = "actor|geology/stone_granite_med.xml";
 const aReeds = "actor|props/flora/reeds_pond_dry.xml";
 const aLillies = "actor|props/flora/water_lillies.xml";
 const aBushMedium = "actor|props/flora/bush_medit_me_dry.xml";
 const aBushSmall = "actor|props/flora/bush_medit_sm_dry.xml";
 
 const pForestD = [tForestFloor + TERRAIN_SEPARATOR + oBeech, tForestFloor];
 const pForestO = [tForestFloor + TERRAIN_SEPARATOR + oOak, tForestFloor];
 const pForestP = [tForestFloor + TERRAIN_SEPARATOR + oPine, tForestFloor];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 
 var [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 for (var i=0; i < numPlayers; i++)
 {
 	playerX[i] *= mapSize;
 	playerZ[i] *= mapSize;
 
 	var startEntities = getStartingEntities(i);
 	// Place starting entities
 	createStartingPlayerEntities(playerX[i], playerZ[i], i+1, startEntities);
 	var uDist = 8;
 	var uSpace = 2;
 	for (var j = 1; j < startEntities.length - 1; ++j)
 	{
 		var uAngle = BUILDING_ORIENTATION - PI * (2-j) / 2;
 		var count = (startEntities[j].Count !== undefined ? startEntities[j].Count : 1);
 		for (var numberofentities = 0; numberofentities < count; numberofentities++)
 		{
 			var ux = playerX[i] + uDist * cos(uAngle) + numberofentities * uSpace * cos(uAngle + PI/2) - (0.75 * uSpace * floor(count / 2) * cos(uAngle + PI/2));
 			var uz = playerZ[i] + uDist * sin(uAngle) + numberofentities * uSpace * sin(uAngle + PI/2) - (0.75 * uSpace * floor(count / 2) * sin(uAngle + PI/2));
 			placeObject(ux, uz, startEntities[j].Template, i+1, uAngle);
 		}
 	}
 
 	// Create treasure
 	var bbAngle = BUILDING_ORIENTATION;
 	var bbDist = 10;
 	var bbX = round(playerX[i] + bbDist * cos(bbAngle));
 	var bbZ = round(playerZ[i] + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oFood, 5,5, 0,2)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	bbAngle += PI/2;
 	var bbX = round(playerX[i] + bbDist * cos(bbAngle));
 	var bbZ = round(playerZ[i] + bbDist * sin(bbAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oWood, 5,5, 0,2)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	bbAngle += PI/2;
 	var bbX = round(playerX[i] + bbDist * cos(bbAngle));
 	var bbZ = round(playerZ[i] + bbDist * sin(bbAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetal, 3,3, 0,2)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	bbAngle += PI/2;
 	var bbX = round(playerX[i] + bbDist * cos(bbAngle));
 	var bbZ = round(playerZ[i] + bbDist * sin(bbAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStone, 2,2, 0,2)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// Base texture
 	var civ = getCivCode(i);
 	var tilesSize = civ == "cart" ? 27 : 22;
 
 	const minBoundX = (playerX[i] > tilesSize ? playerX[i] - tilesSize : 0);
 	const minBoundY = (playerZ[i] > tilesSize ? playerZ[i] - tilesSize : 0);
 	const maxBoundX = (playerX[i] < mapSize - tilesSize ? playerX[i] + tilesSize : mapSize);
 	const maxBoundY = (playerZ[i] < mapSize - tilesSize ? playerZ[i] + tilesSize : mapSize);
 
 	for (var tx = minBoundX; tx < maxBoundX; ++tx)
 		for (var ty = minBoundY; ty < maxBoundY; ++ty)
 		{
 			var unboundSumOfXY = tx + ty - minBoundX - minBoundY;
 			if ((unboundSumOfXY > tilesSize) && (unboundSumOfXY < 3 * tilesSize) && (tx - ty + minBoundY - minBoundX < tilesSize) && (ty - tx - minBoundY + minBoundX < tilesSize))
 			{
 				placeTerrain(floor(tx), floor(ty), tRoad);
 				addToClass(floor(tx), floor(ty), clPlayer);
 			}
 		}
 
 	// Place custom fortress
 	if (civ == "brit" || civ == "gaul" || civ == "iber")
 	{
 		var wall = ["gate", "tower", "wallLong",
 			"cornerIn", "wallLong", "barracks", "tower", "wallLong", "tower", "house", "wallLong",
 			"cornerIn", "wallLong", "house", "tower", "gate", "tower", "house", "wallLong",
 			"cornerIn", "wallLong", "house", "tower", "wallLong", "tower", "house", "wallLong",
 			"cornerIn", "wallLong", "house", "tower"];
 	}
 	else
 	{
 		var wall = ["gate", "tower", "wallLong",
 			"cornerIn", "wallLong", "barracks", "tower", "wallLong", "tower", "wallLong",
 			"cornerIn", "wallLong", "house", "tower", "gate", "tower", "wallLong",
 			"cornerIn", "wallLong", "house", "tower", "wallLong", "tower", "wallLong",
 			"cornerIn", "wallLong", "house", "tower"];
 	}
 	placeCustomFortress(playerX[i], playerZ[i], new Fortress("Spahbod", wall), civ, i+1);
 }
 
 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...");
 createObjectGroupsByAreasDeprecated(
 	new SimpleGroup(
 		[new SimpleObject(oFish, 1,1, 0,1)],
 		true, clFood
 	),
 	0,
 	[stayClasses(clWater, 4),  avoidClasses(clFood, 8)],
 	numLakes / 4,
 	50,
-	waterAreas
-);
+	waterAreas);
 RMS.SetProgress(30);
 
 createBumps(avoidClasses(clWater, 2, clPlayer, 5));
 RMS.SetProgress(35);
 
 log("Creating hills...");
 createHills([tCliff, tCliff, tHill], avoidClasses(clPlayer, 5, clWater, 5, clHill, 15), clHill, scaleByMapSize(1, 4) * numPlayers);
 RMS.SetProgress(40);
 
 // calculate desired number of trees for map (based on size)
 const MIN_TREES = 500;
 const MAX_TREES = 2500;
 const P_FOREST = 0.7;
 
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 var numForest = totalTrees * P_FOREST;
 g_numStragglerTrees = totalTrees * (1.0 - P_FOREST);
 
 log("Creating forests...");
 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...");
 createLayeredPatches(
  [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
  [[tGrass,tGrassA],[tGrassA,tGrassB], [tGrassB,tGrassC]],
  [1,1],
  avoidClasses(clWater, 1, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 1)
 );
 RMS.SetProgress(55);
 
 log("Creating grass patches...");
 createPatches(
  [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
  tGrassPatch,
  avoidClasses(clWater, 1, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 1)
 );
 RMS.SetProgress(60);
 
 log("Creating stone mines...");
 createMines(
  [
   [new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)],
   [new SimpleObject(oStoneSmall, 2,5, 1,3)]
  ],
  avoidClasses(clWater, 0, clForest, 1, clPlayer, 5, clRock, 10, clHill, 1)
 );
 RMS.SetProgress(65);
 
 log("Creating metal mines...");
 createMines(
  [
   [new SimpleObject(oMetalLarge, 1,1, 0,4)]
  ],
  avoidClasses(clWater, 0, clForest, 1, clPlayer, 5, clMetal, 10, clRock, 5, clHill, 1),
  clMetal
 );
 RMS.SetProgress(70);
 
 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),
   scaleByMapSize(13, 200),
   scaleByMapSize(13, 200),
   scaleByMapSize(13, 200)
  ],
  avoidClasses(clWater, 0, clForest, 0, clPlayer, 1, clHill, 0)
 );
 RMS.SetProgress(80);
 
 createFood
 (
  [
   [new SimpleObject(oSheep, 2,3, 0,2)],
   [new SimpleObject(oDeer, 5,7, 0,4)]
  ],
  [
   3 * numPlayers,
   3 * numPlayers
  ],
  avoidClasses(clWater, 0, clForest, 0, clPlayer, 6, clHill, 1, clFood, 20)
 );
 RMS.SetProgress(85);
 
 createFood
 (
  [
   [new SimpleObject(oBerryBush, 5,7, 0,4)]
  ],
  [
   randIntInclusive(1, 4) * numPlayers + 2
  ],
  avoidClasses(clWater, 2, clForest, 0, clPlayer, 6, clHill, 1, clFood, 10)
 );
 
 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");
 setWaterColor(0.157, 0.149, 0.443);
 setWaterTint(0.443,0.42,0.824);
 setWaterWaviness(2.0);
 setWaterType("lake");
 setWaterMurkiness(0.83);
 
 setFogFactor(0.35);
 setFogThickness(0.22);
 setFogColor(0.82,0.82, 0.73);
 setPPSaturation(0.56);
 setPPContrast(0.56);
 setPPBloom(0.38);
 setPPEffect("hdr");
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/gear.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/gear.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/gear.js	(revision 20301)
@@ -1,430 +1,381 @@
 RMS.LoadLibrary("rmgen");
 RMS.LoadLibrary("rmbiome");
 
 TILE_CENTERED_HEIGHT_MAP = true;
 
 setSelectedBiome();
 
 const tMainTerrain = g_Terrains.mainTerrain;
 const tForestFloor1 = g_Terrains.forestFloor1;
 const tForestFloor2 = g_Terrains.forestFloor2;
 const tCliff = g_Terrains.cliff;
 const tTier1Terrain = g_Terrains.tier1Terrain;
 const tTier2Terrain = g_Terrains.tier2Terrain;
 const tTier3Terrain = g_Terrains.tier3Terrain;
 const tHill = g_Terrains.mainTerrain;
 const tRoad = g_Terrains.road;
 const tRoadWild = g_Terrains.roadWild;
 const tTier4Terrain = g_Terrains.tier4Terrain;
 const tShore = g_Terrains.shore;
 const tWater = g_Terrains.water;
 
 const oTree1 = g_Gaia.tree1;
 const oTree2 = g_Gaia.tree2;
 const oTree3 = g_Gaia.tree3;
 const oTree4 = g_Gaia.tree4;
 const oTree5 = g_Gaia.tree5;
 const oFruitBush = g_Gaia.fruitBush;
 const oMainHuntableAnimal = g_Gaia.mainHuntableAnimal;
 const oFish = g_Gaia.fish;
 const oSecondaryHuntableAnimal = g_Gaia.secondaryHuntableAnimal;
 const oStoneLarge = g_Gaia.stoneLarge;
 const oStoneSmall = g_Gaia.stoneSmall;
 const oMetalLarge = g_Gaia.metalLarge;
 
 const aGrass = g_Decoratives.grass;
 const aGrassShort = g_Decoratives.grassShort;
 const aRockLarge = g_Decoratives.rockLarge;
 const aRockMedium = g_Decoratives.rockMedium;
 const aBushMedium = g_Decoratives.bushMedium;
 const aBushSmall = g_Decoratives.bushSmall;
 
 const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
 const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 const mapArea = mapSize*mapSize;
 
-log(mapSize);
-
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 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++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	fx = fractionToTiles(playerX[i]);
 	fz = fractionToTiles(playerZ[i]);
 	ix = round(fx);
 	iz = round(fz);
 	addCivicCenterAreaToClass(ix, iz, clPlayer);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tRoadWild, tRoad], [1]);
 	createArea(placer, painter, null);
 
 	placeCivDefaultEntities(fx, fz, id, { 'iberWall': 'towers' });
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oFruitBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 		mAngle = randFloat(0, TWO_PI);
 
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var num = 2;
 	var tAngle = randFloat(0, TWO_PI);
 	var tDist = randFloat(12, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oTree1, num, num, 0,3)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 
 RMS.SetProgress(20);
 
 var split = 1;
 if (mapSize == 128 && numPlayers <= 2)
 	split = 2;
 else if (mapSize == 192 && numPlayers <= 3)
 	split = 2;
 else if (mapSize == 256)
 {
 	if (numPlayers <= 3)
 		split = 3;
 	else if (numPlayers == 4)
 		split = 2;
 }
 else if (mapSize == 320)
 {
 	if (numPlayers <= 3)
 		split = 3;
 	else if (numPlayers == 4)
 		split = 2;
 }
 else if (mapSize == 384)
 {
 	if (numPlayers <= 3)
 		split = 4;
 	else if (numPlayers == 4)
 		split = 3;
 	else if (numPlayers == 5)
 		split = 2;
 }
 else if (mapSize == 448)
 {
 	if (numPlayers <= 2)
 		split = 5;
 	else if (numPlayers <= 4)
 		split = 4;
 	else if (numPlayers == 5)
 		split = 3;
 	else if (numPlayers == 6)
 		split = 2;
 }
 
-log ("Creating rivers...");
-for (var m = 0; m < numPlayers*split; m++)
+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);
+
+for (let 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));
-
-	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);
+	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);
-
-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);
-
-var fx = fractionToTiles(0.5);
-var fz = fractionToTiles(0.5);
-ix = round(fx);
-iz = round(fz);
-
-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 ring of land connecting players...");
+createArea(
+	new ClumpPlacer(mapArea * 0.15, 1, 1, 10, center, center),
+	new SmoothElevationPainter(ELEVATION_SET, 4, 4),
+	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);
+
+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);
+
+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++)
 {
 	fx = fractionToTiles(playerX[i]);
 	fz = fractionToTiles(playerZ[i]);
 	ix = round(fx);
 	iz = round(fz);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	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);
 }
 
 if (randBool())
 	createHills([tMainTerrain, tCliff, tHill], avoidClasses(clPlayer, 20, clHill, 15, clWater, 2), clHill, scaleByMapSize(1, 4) * numPlayers);
 else
 	createMountains(tCliff, avoidClasses(clPlayer, 20, clHill, 15, clWater, 2), clHill, scaleByMapSize(1, 4) * numPlayers);
 
 createForests(
  [tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
  avoidClasses(clPlayer, 20, clForest, 17, clHill, 0, clWater, 2),
  clForest,
  1,
  ...rBiomeTreeCount(1));
 
 RMS.SetProgress(50);
 
 log("Creating dirt patches...");
 createLayeredPatches(
  [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
  [[tMainTerrain,tTier1Terrain],[tTier1Terrain,tTier2Terrain], [tTier2Terrain,tTier3Terrain]],
  [1,1],
  avoidClasses(clWater, 3, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12)
 );
 
 log("Creating grass patches...");
 createPatches(
  [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
  tTier4Terrain,
  avoidClasses(clWater, 3, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12)
 );
 
 RMS.SetProgress(55);
 
 log("Creating stone mines...");
 createMines(
  [
   [new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)],
   [new SimpleObject(oStoneSmall, 2,5, 1,3)]
  ],
  avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clRock, 10, clHill, 1)
 );
 
 log("Creating metal mines...");
 createMines(
  [
   [new SimpleObject(oMetalLarge, 1,1, 0,4)]
  ],
  avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 1),
  clMetal
 );
 
 log("Creating fish...");
 createObjectGroupsDeprecated(
 	new SimpleGroup([new SimpleObject(oFish, 1,1, 0,3)], true, clFood),
 	0,
 	[stayClasses(clWater, 8), avoidClasses(clFood, 14)],
 	scaleByMapSize(400, 2000),
 	100);
 
 RMS.SetProgress(65);
 
 var planetm = 1;
 
 if (currentBiome() == "tropic")
 	planetm = 8;
 
 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),
   planetm * scaleByMapSize(13, 200),
   planetm * scaleByMapSize(13, 200),
   planetm * scaleByMapSize(13, 200)
  ],
  avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0)
 );
 
 RMS.SetProgress(70);
 
 createFood
 (
  [
   [new SimpleObject(oMainHuntableAnimal, 5,7, 0,4)],
   [new SimpleObject(oSecondaryHuntableAnimal, 2,3, 0,2)]
  ],
  [
   3 * numPlayers,
   3 * numPlayers
  ],
  avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 20)
 );
 
 createFood
 (
  [
   [new SimpleObject(oFruitBush, 5,7, 0,4)]
  ],
  [
   3 * numPlayers
  ],
  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();
Index: ps/trunk/binaries/data/mods/public/maps/random/guadalquivir_river.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/guadalquivir_river.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/guadalquivir_river.js	(revision 20301)
@@ -1,335 +1,336 @@
 RMS.LoadLibrary("rmgen");
 
 const tGrass = ["medit_grass_field_a", "medit_grass_field_b"];
 const tForestFloorC = "medit_plants_dirt";
 const tForestFloorP = "medit_grass_shrubs";
 const tGrassA = "medit_grass_field_b";
 const tGrassB = "medit_grass_field_brown";
 const tGrassC = "medit_grass_field_dry";
 const tRoad = "medit_city_tile";
 const tRoadWild = "medit_city_tile";
 const tGrassPatch = "medit_grass_shrubs";
 const tShore = "sand_grass_25";
 const tWater = "medit_sand_wet";
 
 const oPoplar = "gaia/flora_tree_poplar";
 const oApple = "gaia/flora_tree_apple";
 const oCarob = "gaia/flora_tree_carob";
 const oBerryBush = "gaia/flora_bush_berry";
 const oDeer = "gaia/fauna_deer";
 const oFish = "gaia/fauna_fish";
 const oSheep = "gaia/fauna_sheep";
 const oStoneLarge = "gaia/geology_stonemine_medit_quarry";
 const oStoneSmall = "gaia/geology_stone_mediterranean";
 const oMetalLarge = "gaia/geology_metal_mediterranean_slabs";
 
 const aGrass = "actor|props/flora/grass_soft_large_tall.xml";
 const aGrassShort = "actor|props/flora/grass_soft_large.xml";
 const aReeds = "actor|props/flora/reeds_pond_lush_a.xml";
 const aLillies = "actor|props/flora/water_lillies.xml";
 const aRockLarge = "actor|geology/stone_granite_large.xml";
 const aRockMedium = "actor|geology/stone_granite_med.xml";
 const aBushMedium = "actor|props/flora/bush_medit_me.xml";
 const aBushSmall = "actor|props/flora/bush_medit_sm.xml";
 
 const pForestP = [tForestFloorP + TERRAIN_SEPARATOR + oPoplar, tForestFloorP];
 const pForestC = [tForestFloorC + TERRAIN_SEPARATOR + oCarob, tForestFloorC];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clLand = createTileClass();
 var clRiver = createTileClass();
 var clShallow = createTileClass();
 
 log("Create the continent body");
 createArea(
 	new ChainPlacer(
 		2,
 		Math.floor(scaleByMapSize(5, 12)),
 		Math.floor(scaleByMapSize(60, 700)),
 		1,
 		Math.floor(fractionToTiles(0.5)),
 		Math.floor(fractionToTiles(0.7)),
 		0,
 		[Math.floor(mapSize * 0.49)]),
 	[
 		new LayeredPainter([tGrass, tGrass, tGrass], [4, 2]),
 		new SmoothElevationPainter(ELEVATION_SET, 3, 4),
 		paintClass(clLand)
 	],
 	null);
 
 var playerIDs = primeSortAllPlayers();
 
 // place players
 var playerX = [];
 var playerZ = [];
 var playerAngle = [];
 
 var startAngle = 0;
 for (var i = 0; i < numPlayers; i++)
 {
 	playerAngle[i] = startAngle - 0.23*(i+(i%2))*TWO_PI/numPlayers - (i%2)*PI/2;
 	playerX[i] = 0.5 + 0.35*cos(playerAngle[i]);
 	playerZ[i] = 0.7 + 0.35*sin(playerAngle[i]);
 }
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	let fx = fractionToTiles(playerX[i]);
 	let fz = fractionToTiles(playerZ[i]);
 	let ix = Math.round(fx);
 	let iz = Math.round(fz);
 	addCivicCenterAreaToClass(ix, iz, clPlayer);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	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);
 
 	placeCivDefaultEntities(fx, fz, id, { 'iberWall': false });
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 8;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oBerryBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = 10;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var num = 2;
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(11, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oPoplar, num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 
 RMS.SetProgress(20);
 
 var shallowHeight = -1.5;
 paintRiver({
 	"horizontal": false,
 	"parallel": true,
 	"constraint": stayClasses(clLand, 0),
 	"position": 0.5,
 	"width": 0.07,
 	"fadeDist": 0.025,
 	"deviation": 0.005,
 	"waterHeight": -3,
 	"landHeight": 2,
 	"meanderShort": 12,
 	"meanderLong": 0,
 	"waterFunc": (ix, iz, height) => {
 		addToClass(ix, iz, clRiver);
 		placeTerrain(ix, iz, tWater);
 
 		let z = iz / (mapSize + 1.0);
 
 		if (height < shallowHeight && (
 				z > 0.3 && z < 0.4 ||
 				z > 0.5 && z < 0.6 ||
 				z > 0.7 && z < 0.8))
 		{
 			setHeight(ix, iz, shallowHeight);
 			addToClass(ix, iz, clShallow);
 		}
 	}
 });
 
 paintTerrainBasedOnHeight(1, 3, 0, tShore);
 paintTerrainBasedOnHeight(-8, 1, 2, tWater);
 
 createBumps([avoidClasses(clPlayer, 20, clRiver, 1), stayClasses(clLand, 3)]);
 
 createForests(
  [tGrass, tForestFloorP, tForestFloorC, pForestC, pForestP],
  [avoidClasses(clPlayer, 20, clForest, 17, clHill, 0, clRiver, 1), stayClasses(clLand, 7)],
  clForest,
  1.0);
 
 RMS.SetProgress(50);
 
 log("Creating dirt patches...");
 createLayeredPatches(
  [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
  [[tGrass,tGrassA],[tGrassA,tGrassB], [tGrassB,tGrassC]],
  [1,1],
  [avoidClasses(clForest, 0, clHill, 0, clDirt, 3, clPlayer, 8, clRiver, 1), stayClasses(clLand, 7)]
 );
 
 log("Creating grass patches...");
 createPatches(
  [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
  tGrassPatch,
  [avoidClasses(clForest, 0, clHill, 0, clDirt, 3, clPlayer, 8, clRiver, 1), stayClasses(clLand, 7)]
 );
 
 RMS.SetProgress(55);
 
 log("Creating stone mines...");
 createMines(
  [
   [new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)],
   [new SimpleObject(oStoneSmall, 2,5, 1,3)]
  ],
  [avoidClasses(clForest, 1, clPlayer, 20, clRock, 10, clHill, 1, clRiver, 1), stayClasses(clLand, 5)]
 );
 
 log("Creating metal mines...");
 createMines(
  [
   [new SimpleObject(oMetalLarge, 1,1, 0,4)]
  ],
  [avoidClasses(clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 1, clRiver, 1), stayClasses(clLand, 5)],
  clMetal
 );
 RMS.SetProgress(65);
 
 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),
   scaleByMapSize(13, 200),
   scaleByMapSize(13, 200),
   scaleByMapSize(13, 200)
  ],
  [avoidClasses(clHill, 1, clPlayer, 1, clDirt, 1, clRiver, 1), stayClasses(clLand, 6)]
 );
 
 log("Create water decoration in the shallow parts");
 createDecoration
 (
  [[new SimpleObject(aReeds, 1,3, 0,1)],
   [new SimpleObject(aLillies, 1,2, 0,1)]
  ],
  [
   scaleByMapSize(800, 12800),
   scaleByMapSize(800, 12800)
  ],
  stayClasses(clShallow, 0)
 );
 
 RMS.SetProgress(70);
 
 createFood
 (
  [
   [new SimpleObject(oDeer, 5,7, 0,4)],
   [new SimpleObject(oSheep, 2,3, 0,2)]
  ],
  [
   3 * numPlayers,
   3 * numPlayers
  ],
  [avoidClasses(clForest, 0, clPlayer, 20, clHill, 1, clFood, 20, clRiver, 1), stayClasses(clLand, 3)]
 );
 
 createFood
 (
  [
   [new SimpleObject(oBerryBush, 5,7, 0,4)]
  ],
  [
   randIntInclusive(1, 4) * numPlayers + 2
  ],
  [avoidClasses(clForest, 0, clPlayer, 20, clHill, 1, clFood, 10, clRiver, 1), stayClasses(clLand, 3)]
 );
 
 createFood
 (
  [
   [new SimpleObject(oFish, 2,3, 0,2)]
  ],
  [
   25 * numPlayers
  ],
  avoidClasses(clLand, 2, clRiver, 1)
 );
 
 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);
 setWaterTint(0.1,0.1,0.8);
 setWaterWaviness(4.0);
 setWaterType("lake");
 setWaterMurkiness(0.73);
 
 setFogFactor(0.3);
 setFogThickness(0.25);
 
 setPPEffect("hdr");
 setPPContrast(0.62);
 setPPSaturation(0.51);
 setPPBloom(0.12);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/gulf_of_bothnia.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/gulf_of_bothnia.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/gulf_of_bothnia.js	(revision 20301)
@@ -1,447 +1,387 @@
 RMS.LoadLibrary("rmgen");
 
 TILE_CENTERED_HEIGHT_MAP = true;
 var random_terrain = randIntInclusive(1, 3);
 if (random_terrain == 1)
 {
 	setFogThickness(0.26);
 	setFogFactor(0.4);
 
 	setPPEffect("hdr");
 	setPPSaturation(0.48);
 	setPPContrast(0.53);
 	setPPBloom(0.12);
 
 	var tPrimary = ["alpine_dirt_grass_50"];
 	var tForestFloor = "alpine_forrestfloor";
 	var tCliff = ["alpine_cliff_a", "alpine_cliff_b", "alpine_cliff_c"];
 	var tSecondary = "alpine_grass_rocky";
 	var tHalfSnow = ["alpine_grass_snow_50", "alpine_dirt_snow"];
 	var tSnowLimited = ["alpine_snow_rocky"];
 	var tRoad = "new_alpine_citytile";
 	var tRoadWild = "new_alpine_citytile";
 	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";
 	var oFish = "gaia/fauna_fish";
 	var oRabbit = "gaia/fauna_rabbit";
 	var oStoneLarge = "gaia/geology_stonemine_alpine_quarry";
 	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";
 	var aRockMedium = "actor|geology/stone_granite_med.xml";
 	var aBushMedium = "actor|props/flora/bush_medit_me.xml";
 	var aBushSmall = "actor|props/flora/bush_medit_sm.xml";
 }
 else if (random_terrain == 2)
 {
 	setFogFactor(0.35);
 	setFogThickness(0.19);
 	setPPSaturation(0.37);
 	setPPEffect("hdr");
 
 	var tPrimary = ["alpine_snow_a", "alpine_snow_b"];
 	var tForestFloor = "alpine_forrestfloor_snow";
 	var tCliff = ["alpine_cliff_snow"];
 	var tSecondary = "alpine_grass_snow_50";
 	var tHalfSnow = ["alpine_grass_snow_50", "alpine_dirt_snow"];
 	var tSnowLimited = ["alpine_snow_a", "alpine_snow_b"];
 	var tRoad = "new_alpine_citytile";
 	var tRoadWild = "new_alpine_citytile";
 	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";
 	var oFish = "gaia/fauna_fish";
 	var oRabbit = "gaia/fauna_rabbit";
 	var oStoneLarge = "gaia/geology_stonemine_alpine_quarry";
 	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";
 	var aRockMedium = "actor|geology/stone_granite_med.xml";
 	var aBushMedium = "actor|props/flora/bush_medit_me_dry.xml";
 	var aBushSmall = "actor|props/flora/bush_medit_sm_dry.xml";
 }
 else
 {
 	setFogFactor(0.41);
 	setFogThickness(0.23);
 	setPPSaturation(0.34);
 	setPPEffect("hdr");
 
 	var tPrimary = ["alpine_snow_a", "alpine_snow_b"];
 	var tForestFloor = "alpine_snow_a";
 	var tCliff = ["alpine_cliff_snow"];
 	var tSecondary = "polar_ice_snow";
 	var tHalfSnow = ["polar_ice_cracked"];
 	var tSnowLimited = ["alpine_snow_a", "alpine_snow_b"];
 	var tRoad = "new_alpine_citytile";
 	var tRoadWild = "new_alpine_citytile";
 	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";
 	var oFish = "gaia/fauna_fish";
 	var oRabbit = "gaia/fauna_rabbit";
 	var oStoneLarge = "gaia/geology_stonemine_alpine_quarry";
 	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";
 	var aRockMedium = "actor|geology/stone_granite_med.xml";
 	var aBushMedium = "actor|props/flora/bush_medit_me_dry.xml";
 	var aBushSmall = "actor|props/flora/bush_medit_sm_dry.xml";
 }
 
 const pForest = [tForestFloor + TERRAIN_SEPARATOR + oPine, tForestFloor];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 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++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	ix = round(fx);
 	iz = round(fz);
 	addCivicCenterAreaToClass(ix, iz, clPlayer);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	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);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oBerryBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var num = 2;
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(11, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oPine, num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 
 RMS.SetProgress(20);
 
-//create the gulf
-
-if (random_terrain == 3)
-{
-	var seaHeight = 0;
-}
-else
-{
-	var seaHeight = -3;
-}
-
-//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);
+log("Creating the gulf...");
+var seaHeight = random_terrain == 3 ? 0 : -3;
 
-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)));
+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]
+];
+
+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)
 {
 	paintTerrainBasedOnHeight(2, 3, 0, tShore);
 	paintTerrainBasedOnHeight(-1, 2, 2, tWater);
 }
 else
 {
 	paintTerrainBasedOnHeight(1, 3, 0, tShore);
 	paintTerrainBasedOnHeight(-8, 1, 2, tWater);
 }
 
 createBumps(avoidClasses(clWater, 2, clPlayer, 10));
 
 if (randBool())
 	createHills([tPrimary, tCliff, tPrimary], avoidClasses(clPlayer, 20, clHill, 15, clWater, 0), clHill, scaleByMapSize(1, 4) * numPlayers);
 else
 	createMountains(tCliff, avoidClasses(clPlayer, 20, clHill, 15, clWater, 0), clHill, scaleByMapSize(1, 4) * numPlayers);
 
 createForests(
  [tPrimary, tForestFloor, tForestFloor, pForest, pForest],
  avoidClasses(clPlayer, 20, clForest, 16, clHill, 0, clWater, 2),
  clForest,
- 1.0);
+ 1);
 
 RMS.SetProgress(60);
 
 log("Creating dirt patches...");
 createLayeredPatches(
  [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
  [[tPrimary,tSecondary],[tSecondary,tHalfSnow], [tHalfSnow,tSnowLimited]],
  [1,1],
  avoidClasses(clWater, 6, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12)
 );
 
 log("Creating grass patches...");
 createPatches(
  [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
  tHalfSnow,
  avoidClasses(clWater, 6, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12)
 );
 
 RMS.SetProgress(65);
 
 log("Creating stone mines...");
 createMines(
  [
   [new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)],
   [new SimpleObject(oStoneSmall, 2,5, 1,3)]
  ],
  avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clRock, 10, clHill, 1)
 );
 
 log("Creating metal mines...");
 createMines(
  [
   [new SimpleObject(oMetalLarge, 1,1, 0,4)]
  ],
  avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 1),
  clMetal
 );
 
 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
 (
  [
   [new SimpleObject(oDeer, 5,7, 0,4)],
   [new SimpleObject(oRabbit, 2,3, 0,2)]
  ],
  [
   3 * numPlayers,
   3 * numPlayers
  ],
  avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 20)
 );
 
 createFood
 (
  [
   [new SimpleObject(oBerryBush, 5,7, 0,4)]
  ],
  [
   randIntInclusive(1, 4) * numPlayers + 2
  ],
  avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 10)
 );
 
 if (random_terrain !== 3)
 {
 		createFood
 	(
 	 [
 	  [new SimpleObject(oFish, 2,3, 0,2)]
 	 ],
 	 [
 	  25 * numPlayers
 	 ],
 	 [avoidClasses(clFood, 20), stayClasses(clWater, 6)]
 	);
 }
 
 RMS.SetProgress(85);
 
 log("Creating straggler trees...");
 var types = [oPine];
 createStragglerTrees(types, avoidClasses(clWater, 3, clForest, 1, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6));
 
 setSkySet("stormy");
 setSunRotation(randFloat(0, TWO_PI));
 setSunElevation(randFloat(PI/ 6, PI / 4));
 
 setWaterColor(0.035,0.098,0.314);
 setWaterTint(0.28, 0.3, 0.59);
 setWaterWaviness(5.0);
 setWaterType("lake");
 setWaterMurkiness(0.88);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/harbor.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/harbor.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/harbor.js	(revision 20301)
@@ -1,440 +1,438 @@
 RMS.LoadLibrary("rmgen");
 RMS.LoadLibrary("rmgen2");
 RMS.LoadLibrary("rmbiome");
 
 InitMap();
 
 setSelectedBiome();
 initTileClasses();
 
 setFogFactor(0.04);
 
 resetTerrain(g_Terrains.mainTerrain, g_TileClasses.land, getMapBaseHeight());
 RMS.SetProgress(10);
 
 const mapSize = getMapSize();
 const startAngle = randFloat(0, 2 * Math.PI);
 const players = addBases("radial", 0.38, 0.05, startAngle);
 RMS.SetProgress(20);
 
 addCenterLake();
 RMS.SetProgress(30);
 
 if (mapSize >= 192)
 {
 	addHarbors(players);
 	RMS.SetProgress(40);
 }
 
 addSpines();
 RMS.SetProgress(50);
 
 addElements(shuffleArray([
 	{
 		"func": addHills,
 		"avoid": [
 			g_TileClasses.bluff, 5,
 			g_TileClasses.hill, 15,
 			g_TileClasses.mountain, 2,
 			g_TileClasses.plateau, 5,
 			g_TileClasses.player, 20,
 			g_TileClasses.spine, 5,
 			g_TileClasses.valley, 2,
 			g_TileClasses.water, 2
 		],
 		"sizes": ["tiny", "small"],
 		"mixes": g_AllMixes,
 		"amounts": g_AllAmounts
 	},
 	{
 		"func": addMountains,
 		"avoid": [
 			g_TileClasses.bluff, 20,
 			g_TileClasses.mountain, 25,
 			g_TileClasses.plateau, 20,
 			g_TileClasses.player, 20,
 			g_TileClasses.spine, 20,
 			g_TileClasses.valley, 10,
 			g_TileClasses.water, 15
 		],
 		"sizes": ["small"],
 		"mixes": g_AllMixes,
 		"amounts": g_AllAmounts
 	},
 	{
 		"func": addPlateaus,
 		"avoid": [
 			g_TileClasses.bluff, 20,
 			g_TileClasses.mountain, 25,
 			g_TileClasses.plateau, 20,
 			g_TileClasses.player, 40,
 			g_TileClasses.spine, 20,
 			g_TileClasses.valley, 10,
 			g_TileClasses.water, 15
 		],
 		"sizes": ["small"],
 		"mixes": g_AllMixes,
 		"amounts": g_AllAmounts
 	},
 	{
 		"func": addBluffs,
 		"baseHeight": getMapBaseHeight(),
 		"avoid": [
 			g_TileClasses.bluff, 20,
 			g_TileClasses.mountain, 25,
 			g_TileClasses.plateau, 20,
 			g_TileClasses.player, 40,
 			g_TileClasses.spine, 20,
 			g_TileClasses.valley, 10,
 			g_TileClasses.water, 15
 		],
 		"sizes": ["normal"],
 		"mixes": g_AllMixes,
 		"amounts": g_AllAmounts
 	}
 ]));
 RMS.SetProgress(60);
 
 addElements(shuffleArray([
 	{
 		"func": addMetal,
 		"avoid": [
 			g_TileClasses.berries, 5,
 			g_TileClasses.bluff, 5,
 			g_TileClasses.forest, 3,
 			g_TileClasses.mountain, 2,
 			g_TileClasses.plateau, 2,
 			g_TileClasses.player, 30,
 			g_TileClasses.rock, 10,
 			g_TileClasses.spine, 5,
 			g_TileClasses.metal, 20,
 			g_TileClasses.water, 3
 		],
 		"sizes": ["normal"],
 		"mixes": ["same"],
 		"amounts": ["normal", "many"]
 	},
 	{
 		"func": addStone,
 		"avoid": [
 			g_TileClasses.berries, 5,
 			g_TileClasses.bluff, 5,
 			g_TileClasses.forest, 3,
 			g_TileClasses.mountain, 2,
 			g_TileClasses.plateau, 2,
 			g_TileClasses.player, 30,
 			g_TileClasses.rock, 20,
 			g_TileClasses.spine, 5,
 			g_TileClasses.metal, 10,
 			g_TileClasses.water, 3
 		],
 		"sizes": ["normal"],
 		"mixes": ["same"],
 		"amounts": ["normal", "many"]
 	},
 	{
 		"func": addForests,
 		"avoid": [
 			g_TileClasses.berries, 5,
 			g_TileClasses.bluff, 5,
 			g_TileClasses.forest, 8,
 			g_TileClasses.metal, 3,
 			g_TileClasses.mountain, 5,
 			g_TileClasses.plateau, 5,
 			g_TileClasses.player, 20,
 			g_TileClasses.rock, 3,
 			g_TileClasses.spine, 5,
 			g_TileClasses.water, 2
 		],
 		"sizes": ["normal"],
 		"mixes": ["similar"],
 		"amounts": ["many"]
 	}
 ]));
 
 RMS.SetProgress(70);
 
 addElements(shuffleArray([
 	{
 		"func": addBerries,
 		"avoid": [
 			g_TileClasses.berries, 30,
 			g_TileClasses.bluff, 5,
 			g_TileClasses.forest, 5,
 			g_TileClasses.metal, 10,
 			g_TileClasses.mountain, 2,
 			g_TileClasses.plateau, 2,
 			g_TileClasses.player, 20,
 			g_TileClasses.rock, 10,
 			g_TileClasses.spine, 2,
 			g_TileClasses.water, 3
 		],
 		"sizes": g_AllSizes,
 		"mixes": g_AllMixes,
 		"amounts": g_AllAmounts
 	},
 	{
 		"func": addAnimals,
 		"avoid": [
 			g_TileClasses.animals, 20,
 			g_TileClasses.bluff, 5,
 			g_TileClasses.forest, 2,
 			g_TileClasses.metal, 2,
 			g_TileClasses.mountain, 1,
 			g_TileClasses.plateau, 2,
 			g_TileClasses.player, 20,
 			g_TileClasses.rock, 2,
 			g_TileClasses.spine, 2,
 			g_TileClasses.water, 3
 		 ],
 		"sizes": g_AllSizes,
 		"mixes": g_AllMixes,
 		"amounts": g_AllAmounts
 	},
 	{
 		"func": addStragglerTrees,
 		"avoid": [
 			g_TileClasses.berries, 5,
 			g_TileClasses.bluff, 5,
 			g_TileClasses.forest, 7,
 			g_TileClasses.metal, 2,
 			g_TileClasses.mountain, 1,
 			g_TileClasses.plateau, 2,
 			g_TileClasses.player, 12,
 			g_TileClasses.rock, 2,
 			g_TileClasses.spine, 2,
 			g_TileClasses.water, 5
 		 ],
 		"sizes": g_AllSizes,
 		"mixes": g_AllMixes,
 		"amounts": g_AllAmounts
 	}
 ]));
 
 RMS.SetProgress(80);
 
 addElements([
 	{
 		"func": addLayeredPatches,
 		"avoid": [
 			g_TileClasses.bluff, 2,
 			g_TileClasses.dirt, 5,
 			g_TileClasses.forest, 2,
 			g_TileClasses.mountain, 2,
 			g_TileClasses.plateau, 2,
 			g_TileClasses.player, 12,
 			g_TileClasses.spine, 5,
 			g_TileClasses.water, 3
 		],
 		"sizes": ["normal"],
 		"mixes": ["normal"],
 		"amounts": ["normal"]
 	},
 	{
 		"func": addDecoration,
 		"avoid": [
 			g_TileClasses.bluff, 2,
 			g_TileClasses.forest, 2,
 			g_TileClasses.mountain, 2,
 			g_TileClasses.plateau, 2,
 			g_TileClasses.player, 12,
 			g_TileClasses.spine, 5,
 			g_TileClasses.water, 3
 		],
 		"sizes": ["normal"],
 		"mixes": ["normal"],
 		"amounts": ["normal"]
 	}
 ]);
 
 RMS.SetProgress(90);
 
 ExportMap();
 
 function addCenterLake()
 {
-	let lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 6))));
 	let center = Math.round(fractionToTiles(0.5));
 
 	createArea(
 		new ChainPlacer(
 			2,
 			Math.floor(scaleByMapSize(2, 12)),
 			Math.floor(scaleByMapSize(35, 160)),
 			1,
 			center,
 			center,
 			0,
-			[Math.floor(mapSize * 0.17 * lSize)]
-		),
+			[Math.floor(mapSize * 0.17 * Math.pow(scaleByMapSize(1, 6), 1/8))]),
 		[
 			new LayeredPainter(
 				[
 					g_Terrains.shore,
 					g_Terrains.water,
 					g_Terrains.water
 				],
 				[1, 100]
 			),
 			new SmoothElevationPainter(ELEVATION_SET, -18, 10),
 			paintClass(g_TileClasses.water)
 		],
 		avoidClasses(g_TileClasses.player, 20)
 	);
 
 	let fDist = 50;
 	if (mapSize <= 192)
 		fDist = 20;
 
 	// create a bunch of fish
 	createObjectGroup(
 		new SimpleGroup(
 			[new SimpleObject(g_Gaia.fish, 20, 30, 0, fDist)],
 			true,
 			g_TileClasses.baseResource,
 			center,
 			center
 		),
 		0,
 		[
 			avoidClasses(g_TileClasses.player, 5, g_TileClasses.hill, 3, g_TileClasses.mountain, 3),
 			stayClasses(g_TileClasses.water, 5)
 		]
 	);
 }
 
 function addHarbors(players)
 {
 	let center = Math.round(fractionToTiles(0.5));
 
 	for (let i = 0; i < players.length; ++i)
 	{
 		let ix = round(fractionToTiles(players[i].x));
 		let iz = round(fractionToTiles(players[i].z));
 
 		let offsetX = Math.round((center - ix) / 2.5);
 		let offsetZ = Math.round((center - iz) / 2.5);
 
 		createArea(
 			new ClumpPlacer(scaleByMapSize(1200, 1200), 0.5, 0.5, 1, ix + offsetX, iz + offsetZ),
 			[
 				new LayeredPainter([g_Terrains.shore, g_Terrains.water], [2]),
 				new SmoothElevationPainter(ELEVATION_MODIFY, -11, 3),
 				paintClass(g_TileClasses.water)
 			],
 			avoidClasses(
 				g_TileClasses.player, 15,
 				g_TileClasses.hill, 1
 			)
 		);
 
 		// create fish in harbor
 		createObjectGroup(
 			new SimpleGroup(
 				[new SimpleObject(g_Gaia.fish, 6, 6, 1, 20)],
 				true, g_TileClasses.baseResource, ix + offsetX, iz + offsetZ
 			),
 			0,
 			[
 				avoidClasses(
 					g_TileClasses.hill, 3,
 					g_TileClasses.mountain, 3
 				),
 				stayClasses(g_TileClasses.water, 5)
 			]
 		);
 	}
 }
 
 function addSpines()
 {
 	let numPlayers = getNumPlayers();
 	let spineTile = g_Terrains.dirt;
 	let elevation = 35;
 
 	if (currentBiome() == "snowy")
 		spineTile = g_Terrains.tier1Terrain;
 
 	if (currentBiome() == "alpine" || currentBiome() == "savanna")
 		spineTile = g_Terrains.tier2Terrain;
 
 	if (currentBiome() == "autumn")
 		spineTile = g_Terrains.tier4Terrain;
 
 	let split = 1;
 	if (numPlayers <= 3 || mapSize >= 320 && numPlayers <= 4)
 		split = 2;
 
 	for (let i = 0; i < numPlayers * split; ++i)
 	{
 		let tang = startAngle + (i + 0.5) * 2 * Math.PI / (numPlayers * split);
 
 		let mStartCo = 0.12;
 		let mStopCo = 0.40;
 		let mSize = 0.5;
 		let mWaviness = 0.6;
 		let mOffset = 0.4;
 		let mTaper = -1.4;
 
 		// make small mountain dividers if we're on a small map
 		if (mapSize <= 192)
 		{
 			mSize = 0.02;
 			mTaper = -0.1;
 			elevation = 20;
 		}
 
 		createArea(
 			new PathPlacer(
 				fractionToTiles(0.5 + mStartCo * cos(tang)),
 				fractionToTiles(0.5 + mStartCo * sin(tang)),
 				fractionToTiles(0.5 + mStopCo * cos(tang)),
 				fractionToTiles(0.5 + mStopCo * sin(tang)),
 				scaleByMapSize(14, mSize),
 				mWaviness,
 				0.1,
 				mOffset,
 				mTaper
 			),
 			[
 				new LayeredPainter([g_Terrains.cliff, spineTile], [3]),
 				new SmoothElevationPainter(ELEVATION_MODIFY, elevation, 3),
 				paintClass(g_TileClasses.spine)
 			],
 			avoidClasses(g_TileClasses.player, 5)
 		);
 	}
 
 	addElements([
 		{
 			"func": addDecoration,
 			"avoid": [
 				g_TileClasses.bluff, 2,
 				g_TileClasses.forest, 2,
 				g_TileClasses.mountain, 2,
 				g_TileClasses.player, 12,
 				g_TileClasses.water, 3
 			],
 			"stay": [g_TileClasses.spine, 5],
 			"sizes": ["normal"],
 			"mixes": ["normal"],
 			"amounts": ["normal"]
 		}
 	]);
 
 	addElements([
 		{
 			"func": addProps,
 			"avoid": [
 				g_TileClasses.forest, 2,
 				g_TileClasses.player, 2,
 				g_TileClasses.prop, 20,
 				g_TileClasses.water, 3
 			],
 			"stay": [g_TileClasses.spine, 8],
 			"sizes": ["normal"],
 			"mixes": ["normal"],
 			"amounts": ["scarce"]
 		}
 	]);
 }
Index: ps/trunk/binaries/data/mods/public/maps/random/hyrcanian_shores.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/hyrcanian_shores.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/hyrcanian_shores.js	(revision 20301)
@@ -1,433 +1,393 @@
 RMS.LoadLibrary("rmgen");
 
 const tGrass = ["temp_grass_clovers"];
 const tGrassPForest = "temp_plants_bog";
 const tGrassDForest = "alpine_dirt_grass_50";
 const tCliff = ["temp_cliff_a", "temp_cliff_b"];
 const tGrassA = "temp_grass_d";
 const tGrassB = "temp_grass_c";
 const tGrassC = "temp_grass_clovers_2";
 const tHill = ["temp_highlands", "temp_grass_long_b"];
 const tRoad = "temp_road";
 const tRoadWild = "temp_road_overgrown";
 const tGrassPatch = "temp_grass_plants";
 const tShore = "medit_sand_wet";
 const tWater = "medit_sand_wet";
 
 const oPoplar = "gaia/flora_tree_poplar";
 const oPalm = "gaia/flora_tree_cretan_date_palm_short";
 const oApple = "gaia/flora_tree_apple";
 const oOak = "gaia/flora_tree_oak";
 const oBerryBush = "gaia/flora_bush_berry";
 const oDeer = "gaia/fauna_deer";
 const oFish = "gaia/fauna_fish";
 const oGoat = "gaia/fauna_goat";
 const oBoar = "gaia/fauna_boar";
 const oStoneLarge = "gaia/geology_stonemine_temperate_quarry";
 const oStoneSmall = "gaia/geology_stone_temperate";
 const oMetalLarge = "gaia/geology_metal_temperate_slabs";
 
 const aGrass = "actor|props/flora/grass_soft_large_tall.xml";
 const aGrassShort = "actor|props/flora/grass_soft_large.xml";
 const aRockLarge = "actor|geology/stone_granite_large.xml";
 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];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clSea = createTileClass();
 var clHighlands = createTileClass();
 var clFlatlands = createTileClass();
 
 var playerIDs = sortAllPlayers();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	var fx = fractionToTiles((i + 1) / (numPlayers + 1));
 	var fz = fractionToTiles(0.4 + 0.2 * (i % 2));
 	var ix = round(fx);
 	var iz = round(fz);
 
 	addCivicCenterAreaToClass(ix, iz, clPlayer);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	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);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oBerryBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 		mAngle = randFloat(0, TWO_PI);
 
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var num = 2;
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(11, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oOak, num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 RMS.SetProgress(10);
 
 paintRiver({
 	"horizontal": true,
 	"parallel": true,
 	"position": 1,
 	"width": 0.5,
 	"fadeDist": 0.05,
 	"deviation": 0,
 	"waterHeight": -3,
 	"landHeight": 1,
 	"meanderShort": 20,
 	"meanderLong": 0,
 	"waterFunc": (ix, iz, height) => {
 
 		if (height < 0)
 			addToClass(ix, iz, clWater);
 
 		if (height < -1.5)
 			placeTerrain(ix, iz, tWater);
 		else
 			placeTerrain(ix, iz, tShore);
 	},
 	"landFunc": (ix, iz, shoreDist1, shoreDist2) => {
 		addToClass(ix, iz, clHighlands);
 	}
 });
 
 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);
 
 // calculate desired number of trees for map (based on size)
 const MIN_TREES = 500;
 const MAX_TREES = 2500;
 const P_FOREST = 0.7;
 
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 var numForest = totalTrees * P_FOREST;
 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);
 
 log("Creating stone mines...");
 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, clSea, 2, clHill, 2)],
 	scaleByMapSize(4,16), 100
 );
 
 log("Creating small stone quarries...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clWater, 0, clForest, 1, clPlayer, 20, clRock, 10, clSea, 2, clHill, 2)],
 	scaleByMapSize(4,16), 100
 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clWater, 0, clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clSea, 0, clHill, 2)],
 	scaleByMapSize(4,16), 100
 );
 
 RMS.SetProgress(85);
 
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockMedium, 1,3, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0, clSea, 0),
 	scaleByMapSize(16, 262), 50
 );
 RMS.SetProgress(90);
 
 log("Creating large decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0, clSea, 0),
 	scaleByMapSize(8, 131), 50
 );
 
 log("Creating deer...");
 group = new SimpleGroup(
 	[new SimpleObject(oDeer, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 0, clForest, 0, clPlayer, 20, clHill, 0, clFood, 5, clSea, 0, clFlatlands, 0),
 	6 * numPlayers, 50
 );
 
 log("Creating sheep...");
 group = new SimpleGroup(
 	[new SimpleObject(oGoat, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 0, clForest, 0, clPlayer, 20, clHill, 0, clFood, 20, clSea, 0),
 	3 * numPlayers, 50
 );
 
 log("Creating berry bush...");
 group = new SimpleGroup(
 	[new SimpleObject(oBerryBush, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 6, clForest, 0, clPlayer, 20, clHill, 1, clFood, 10),
 	randIntInclusive(1, 4) * numPlayers + 2, 50
 );
 
 log("Creating boar...");
 group = new SimpleGroup(
 	[new SimpleObject(oBoar, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 0, clForest, 0, clPlayer, 20, clHill, 0, clFood, 20, clSea, 0, clFlatlands, 0),
 	2 * numPlayers, 50
 );
 
 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(
 	[new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)]
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 2, clHill, 2, clPlayer, 2, clDirt, 0, clSea, 1),
 	scaleByMapSize(13, 200)
 );
 
 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,
 	avoidClasses(clWater, 3, clHill, 2, clPlayer, 2, clDirt, 1, clForest, 0, clSea, 1),
 	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,
 	avoidClasses(clWater, 1, clHill, 1, clPlayer, 1, clDirt, 1, clSea, 1),
 	scaleByMapSize(13, 200), 50
 );
 
 setSkySet("cirrus");
 setWaterColor(0.114, 0.192, 0.463);
 setWaterTint(0.255, 0.361, 0.651);
 setWaterWaviness(2.0);
 setWaterType("ocean");
 setWaterMurkiness(0.83);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/island_stronghold.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/island_stronghold.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/island_stronghold.js	(revision 20301)
@@ -1,549 +1,511 @@
 /**
  * Returns starting position in tile coordinates for the given player.
  */
 function getPlayerTileCoordinates(playerIdx, teamIdx, fractionX, fractionZ)
 {
 	let playerAngle = startAngle + (playerIdx+1) * TWO_PI / teams[teamIdx].length;
 
 	let fx = fractionToTiles(fractionX + 0.05 * cos(playerAngle));
 	let fz = fractionToTiles(fractionZ + 0.05 * sin(playerAngle));
 
 	return [playerAngle, fx, fz, round(fx), round(fz)];
 }
 
 RMS.LoadLibrary("rmgen");
 RMS.LoadLibrary("rmbiome");
 RMS.LoadLibrary("heightmap");
 
 const g_InitialMines = 1;
 const g_InitialMineDistance = 14;
 const g_InitialTrees = 50;
 
 setSelectedBiome();
 
 const tMainTerrain = g_Terrains.mainTerrain;
 const tForestFloor1 = g_Terrains.forestFloor1;
 const tForestFloor2 = g_Terrains.forestFloor2;
 const tCliff = g_Terrains.cliff;
 const tTier1Terrain = g_Terrains.tier1Terrain;
 const tTier2Terrain = g_Terrains.tier2Terrain;
 const tTier3Terrain = g_Terrains.tier3Terrain;
 const tHill = g_Terrains.hill;
 const tTier4Terrain = g_Terrains.tier4Terrain;
 const tShore = g_Terrains.shore;
 const tWater = g_Terrains.water;
 
 const oTree1 = g_Gaia.tree1;
 const oTree2 = g_Gaia.tree2;
 const oTree3 = g_Gaia.tree3;
 const oTree4 = g_Gaia.tree4;
 const oTree5 = g_Gaia.tree5;
 const oFruitBush = g_Gaia.fruitBush;
 const oMainHuntableAnimal = g_Gaia.mainHuntableAnimal;
 const oFish = g_Gaia.fish;
 const oSecondaryHuntableAnimal = g_Gaia.secondaryHuntableAnimal;
 const oStoneLarge = g_Gaia.stoneLarge;
 const oStoneSmall = g_Gaia.stoneSmall;
 const oMetalLarge = g_Gaia.metalLarge;
 const oWhale = "gaia/fauna_whale_humpback";
 const oShipwreck = "other/special_treasure_shipwreck";
 const oShipDebris = "other/special_treasure_shipwreck_debris";
 const oObelisk = "other/obelisk";
 
 const aGrass = g_Decoratives.grass;
 const aGrassShort = g_Decoratives.grassShort;
 const aRockLarge = g_Decoratives.rockLarge;
 const aRockMedium = g_Decoratives.rockMedium;
 
 const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
 const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
 
 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();
 
-initTerrain(tWater);
-
-// some constants
-let radius = scaleByMapSize(15, 25);
+const shoreRadius = 6;
+const landHeight = 3;
 
-let fx = fractionToTiles(0.5);
-let fz = fractionToTiles(0.5);
+initTerrain(tWater);
 
-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);
 	if (team == -1)
 		continue;
 
 	if (!teams[team])
 		teams[team] = [];
 
 	teams[team].push(i+1);
 }
 
 // Players without a team get a custom index
 for (let i = 0; i < numPlayers; ++i)
 {
 	let team = getPlayerTeam(i);
 	if (team != -1)
 		continue;
 
 	let unusedIndex = teams.findIndex(team => !team);
 
 	if (unusedIndex != -1)
 		teams[unusedIndex] = [i+1];
 	else
 		teams.push([i+1]);
 }
 
 // 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])
 		continue;
 
 	++teamNo;
 	let teamAngle = startAngle + teamNo*TWO_PI/numTeams;
 	let fractionX = 0.5 + 0.3 * cos(teamAngle);
 	let fractionZ = 0.5 + 0.3 * sin(teamAngle);
 	let teamX = fractionToTiles(fractionX);
 	let teamZ = fractionToTiles(fractionZ);
 
 	log("Creating island and starting entities for team " + i);
 	for (let p = 0; p < teams[i].length; ++p)
 	{
 		let [playerAngle, fx, fz, ix, iz] = getPlayerTileCoordinates(p, i, fractionX, fractionZ);
 
 		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 });
 	}
 
 	log("Create initial mines for team " + i);
 	for (let p = 0; p < teams[i].length; ++p)
 	{
 		let [playerAngle, fx, fz, ix, iz] = getPlayerTileCoordinates(p, i, fractionX, fractionZ);
 		let mAngle = randFloat(playerAngle - PI / teams[i].length, playerAngle + PI / teams[i].length);
 
 		// Metal
 		let mX = round(fx + g_InitialMineDistance * cos(mAngle));
 		let mZ = round(fz + g_InitialMineDistance * sin(mAngle));
 		let group = new SimpleGroup(
 			[new SimpleObject(oMetalLarge, g_InitialMines, g_InitialMines, 0, 4)],
 			true, clBaseResource, mX, mZ
 		);
 		createObjectGroup(group, 0, [avoidClasses(clBaseResource, 2, clPlayer, 4), stayClasses(clLand, 2)]);
 
 		// Stone
 		let sX = round(fx + g_InitialMineDistance * cos(mAngle + PI/4));
 		let sZ = round(fz + g_InitialMineDistance * sin(mAngle + PI/4));
 		group = new SimpleGroup(
 			[new SimpleObject(oStoneLarge, g_InitialMines, g_InitialMines, 0, 4)],
 			true, clBaseResource, sX, sZ
 		);
 		createObjectGroup(group, 0, [avoidClasses(clBaseResource, 2, clPlayer, 4), stayClasses(clLand, 2)]);
 	}
 
 	log("Place initial trees and animals for team " + i);
 	for (let p = 0; p < teams[i].length; ++p)
 	{
 		let [playerAngle, fx, fz, ix, iz] = getPlayerTileCoordinates(p, i, fractionX, fractionZ);
 
 		placeDefaultChicken(fx, fz, clBaseResource, [stayClasses(clLand, 5)]);
 
 		// create initial berry bushes
 		let bbAngle = randFloat(PI, PI*1.5);
 		let bbDist = 10;
 		let bbX = round(fx + bbDist * cos(bbAngle));
 		let bbZ = round(fz + bbDist * sin(bbAngle));
 		let group = new SimpleGroup(
 			[new SimpleObject(oFruitBush, 5, 5, 0, 3)],
 			true, clBaseResource, bbX, bbZ
 		);
 		createObjectGroup(group, 0, [avoidClasses(clBaseResource, 4, clPlayer, 4), stayClasses(clLand, 5)]);
 
 		// create initial trees
 		let tries = 10;
 		let tDist = 16;
 		for (let x = 0; x < tries; ++x)
 		{
 			let tAngle = randFloat(playerAngle - TWO_PI/teams[i].length,
 			                       playerAngle + TWO_PI/teams[i].length);
 
 			let tX = round(fx + tDist * cos(tAngle));
 			let tZ = round(fz + tDist * sin(tAngle));
 
 			group = new SimpleGroup(
 				[new SimpleObject(oTree2, g_InitialTrees, g_InitialTrees, 0, 7)],
 				true, clBaseResource, tX, tZ
 			);
 			if (createObjectGroup(group, 0, [avoidClasses(clBaseResource, 4, clPlayer, 4), stayClasses(clLand, 4)]))
 				break;
 		}
 
 		// create huntable animals
 		group = new SimpleGroup(
 			[new SimpleObject(oMainHuntableAnimal, 2 * numPlayers / numTeams, 2 * numPlayers / numTeams, 0, floor(mapSize * 0.2))],
 			true, clBaseResource, teamX, teamZ
 		);
 		createObjectGroup(group, 0, [avoidClasses(clBaseResource, 2, clHill, 1, clPlayer, 10), stayClasses(clLand, 5)]);
 		group = new SimpleGroup(
 			[new SimpleObject(oSecondaryHuntableAnimal, 4 * numPlayers / numTeams, 4 * numPlayers / numTeams, 0, floor(mapSize * 0.2))],
 			true, clBaseResource, teamX, teamZ
 		);
 		createObjectGroup(group, 0, [avoidClasses(clBaseResource, 2, clHill, 1, clPlayer, 10), stayClasses(clLand, 5)]);
 	}
 }
 
 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)
 		if (playerConstraint.allows(x, z) && landConstraint.allows(x, z))
 			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
 	);
 
 	if (!newIsland || !newIsland.length)
 		continue;
 
 	let n = 0;
 	for (let j = 0; j < landAreaLen; ++j)
 	{
 		let x = landAreas[j][0];
 		let z = landAreas[j][1];
 
 		if (playerConstraint.allows(x, z) && landConstraint.allows(x, z))
 			landAreas[n++] = landAreas[j];
 	}
 	landAreas.length = n;
 }
 
 playerConstraint = new AvoidTileClassConstraint(clPlayer, floor(scaleByMapSize(9, 12)));
 landConstraint = new AvoidTileClassConstraint(clLand, floor(scaleByMapSize(9, 12)));
 
 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;
 
 	let temp = [];
 	for (let j = 0; j < landAreaLen; ++j)
 	{
 		let x = landAreas[j][0];
 		let z = landAreas[j][1];
 
 		if (playerConstraint.allows(x, z) && landConstraint.allows(x, z))
 			temp.push([x, z]);
 	}
 	landAreas = temp;
 }
 
 RMS.SetProgress(70);
 
 log("Smoothing heightmap...");
 for (let i = 0; i < 5; ++i)
 	globalSmoothHeightmap();
 
 // repaint clLand to compensate for smoothing
 unPaintTileClassBasedOnHeight(-10, 10, 3, clLand);
 paintTileClassBasedOnHeight(0, 5, 3, clLand);
 
 RMS.SetProgress(85);
 
 createBumps();
 
 createMines(
 [
 	[new SimpleObject(oMetalLarge, 1, 1, 3, (numPlayers * 2) + 1)]
 ],
 [avoidClasses(clForest, 1, clPlayer, 40, clRock, 20, clHill, 5), stayClasses(clLand, 4)],
 clMetal
 );
 
 createMines(
 [
 	[new SimpleObject(oStoneLarge, 1, 1, 3, (numPlayers * 2) + 1)], [new SimpleObject(oStoneSmall, 2, 2, 2, (numPlayers * 2) + 1)]
 ],
 [avoidClasses(clForest, 1, clPlayer, 40, clMetal, 20, clHill, 5), stayClasses(clLand, 4)],
 clRock
 );
 
 createForests(
  [tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
  [avoidClasses(clPlayer, 10, clForest, 20, clHill, 10, clBaseResource, 5, clRock, 6, clMetal, 6), stayClasses(clLand, 3)],
  clForest,
  1,
  ...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();
 
 createStragglerTrees(
 		[oTree1, oTree2, oTree4, oTree3],
 		[avoidClasses(clForest, 10, clPlayer, 20, clMetal, 6, clRock, 6, clHill, 1),
 		 stayClasses(clLand, 4)]
 );
 
 createFood(
 	[
 		[new SimpleObject(oMainHuntableAnimal, 5, 7, 0, 4)],
 		[new SimpleObject(oSecondaryHuntableAnimal, 2, 3, 0, 2)]
 	],
 	[3 * numPlayers, 3 * numPlayers],
 	[avoidClasses(clForest, 0, clPlayer, 20, clHill, 1, clRock, 6, clMetal, 6), stayClasses(clLand, 2)]
 );
 
 createFood(
 	[
 		[new SimpleObject(oFruitBush, 5, 7, 0, 4)]
 	],
 	[3 * numPlayers],
 	[avoidClasses(clForest, 0, clPlayer, 15, clHill, 1, clFood, 4, clRock, 6, clMetal, 6), stayClasses(clLand, 2)]
 );
 
 if (currentBiome() == "desert")
 {
 	log("Creating obelisks");
 	let group = new SimpleGroup(
 		[new SimpleObject(oObelisk, 1, 1, 0, 1)],
 		true
 	);
 	createObjectGroupsDeprecated(
 		group, 0,
 		[avoidClasses(clBaseResource, 0, clHill, 0, clRock, 0, clMetal, 0, clFood, 0), stayClasses(clLand, 1)],
 		scaleByMapSize(3, 8), 1000
 	);
 }
 
 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(
 	[new SimpleObject(aRockMedium, 1, 3, 0, 1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	[avoidClasses(clForest, 0, clHill, 0), stayClasses(clLand, 2)],
 	scaleByMapSize(16, 262), 50
 );
 
 log("Creating large decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockLarge, 1, 2, 0, 1), new SimpleObject(aRockMedium, 1, 3, 0, 2)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	[avoidClasses(clForest, 0, clHill, 0), stayClasses(clLand, 2)],
 	scaleByMapSize(8, 131), 50
 );
 
 log("Creating fish...");
 group = new SimpleGroup(
 	[new SimpleObject(oFish, 2, 3, 0, 2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clLand, 4, clFood, 20),
 	25 * numPlayers, 60
 );
 
 log("Creating Whales...");
 group = new SimpleGroup(
 	[new SimpleObject(oWhale, 1, 1, 0, 3)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clLand, 4),avoidClasses(clFood, 8)],
 	scaleByMapSize(5, 20), 100
 );
 
 log("Creating shipwrecks...");
 group = new SimpleGroup(
 	[new SimpleObject(oShipwreck, 1, 1, 0, 1)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clLand, 4),avoidClasses(clFood, 8)],
 	scaleByMapSize(12, 16), 100
 );
 
 log("Creating shipwreck debris...");
 group = new SimpleGroup(
 	[new SimpleObject(oShipDebris, 1, 1, 0, 1)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clLand, 4),avoidClasses(clFood, 8)],
 	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(
 	[new SimpleObject(aGrassShort, 1, 2, 0, 1, -PI / 8, PI / 8)]
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clHill, 2, clPlayer, 2, clDirt, 0), stayClasses(clLand, 3)],
 	planetm * scaleByMapSize(13, 200)
 );
 
 RMS.SetProgress(95);
 
 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,
 	[avoidClasses(clHill, 2, clPlayer, 2, clDirt, 1, clForest, 0), stayClasses(clLand, 5)],
 	planetm * scaleByMapSize(13, 200)
 );
 
 paintTerrainBasedOnHeight(1, 2, 0, tShore);
 paintTerrainBasedOnHeight(getMapBaseHeight(), 1, 3, tWater);
 
 setSkySet(pickRandom(["cloudless", "cumulus", "overcast"]));
 setSunRotation(randFloat(0, TWO_PI));
 setSunElevation(randFloat(PI/5, PI/3));
 setWaterWaviness(2);
 
 RMS.SetProgress(100);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/islands.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/islands.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/islands.js	(revision 20301)
@@ -1,519 +1,498 @@
 RMS.LoadLibrary("rmgen");
 RMS.LoadLibrary("rmbiome");
 
 TILE_CENTERED_HEIGHT_MAP = true;
 
 setSelectedBiome();
 
 const tMainTerrain = g_Terrains.mainTerrain;
 const tForestFloor1 = g_Terrains.forestFloor1;
 const tForestFloor2 = g_Terrains.forestFloor2;
 const tCliff = g_Terrains.cliff;
 const tTier1Terrain = g_Terrains.tier1Terrain;
 const tTier2Terrain = g_Terrains.tier2Terrain;
 const tTier3Terrain = g_Terrains.tier3Terrain;
 const tHill = g_Terrains.hill;
 const tRoad = g_Terrains.road;
 const tRoadWild = g_Terrains.roadWild;
 const tTier4Terrain = g_Terrains.tier4Terrain;
 const tShore = g_Terrains.shore;
 const tWater = g_Terrains.water;
 
 const oTree1 = g_Gaia.tree1;
 const oTree2 = g_Gaia.tree2;
 const oTree3 = g_Gaia.tree3;
 const oTree4 = g_Gaia.tree4;
 const oTree5 = g_Gaia.tree5;
 const oFruitBush = g_Gaia.fruitBush;
 const oMainHuntableAnimal = g_Gaia.mainHuntableAnimal;
 const oFish = g_Gaia.fish;
 const oSecondaryHuntableAnimal = g_Gaia.secondaryHuntableAnimal;
 const oStoneLarge = g_Gaia.stoneLarge;
 const oStoneSmall = g_Gaia.stoneSmall;
 const oMetalLarge = g_Gaia.metalLarge;
 const oWood = "gaia/special_treasure_wood";
 
 const aGrass = g_Decoratives.grass;
 const aGrassShort = g_Decoratives.grassShort;
 const aRockLarge = g_Decoratives.rockLarge;
 const aRockMedium = g_Decoratives.rockMedium;
 const aBushMedium = g_Decoratives.bushMedium;
 const aBushSmall = g_Decoratives.bushSmall;
 
 const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
 const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clLand = createTileClass();
 
 var [playerIDs, playerX, playerZ, playerAngle] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(20,29);
 	var shoreRadius = 6;
 	var elevation = 3;
 
 	var hillSize = PI * radius * radius;
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 	// create the hill
 	var placer = new ClumpPlacer(hillSize, 0.80, 0.1, 10, ix, iz);
 	var terrainPainter = new LayeredPainter(
 		[tMainTerrain , tMainTerrain, tMainTerrain],		// terrains
 		[1, shoreRadius]		// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		elevation,				// elevation
 		shoreRadius				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clPlayer)], null);
 
 	placeCivDefaultEntities(fx, fz, id, { 'iberWall': 'towers' });
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oFruitBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create woods
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 13;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oWood, 14,14, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 	var hillSize = PI * radius * radius;
 	// create starting trees
 	var num = 5;
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(12, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oTree1, num, num, 0,3)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	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);
 }
 
 var landAreas = [];
 var playerConstraint = new AvoidTileClassConstraint(clPlayer, floor(scaleByMapSize(12,16)));
 var landConstraint = new AvoidTileClassConstraint(clLand, floor(scaleByMapSize(12,16)));
 
 for (var x = 0; x < mapSize; ++x)
 	for (var z = 0; z < mapSize; ++z)
 		if (playerConstraint.allows(x, z) && landConstraint.allows(x, z))
 			landAreas.push([x, z]);
 
 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)
 		break;
 
 	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];
 		}
 		landAreas.length = n;
 	}
 }
 
 playerConstraint = new AvoidTileClassConstraint(clPlayer, floor(scaleByMapSize(9,12)));
 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)
 		break;
 
 	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]);
 		}
 		landAreas = temp;
 	}
 }
 paintTerrainBasedOnHeight(1, 3, 0, tShore);
 paintTerrainBasedOnHeight(-8, 1, 2, tWater);
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 	// create the city patch
 	var cityRadius = radius/3;
 	placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tRoadWild, tRoad], [1]);
 	createArea(placer, painter, null);
 }
 
 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")
 {
 	var MIN_TREES = 200;
 	var MAX_TREES = 1250;
 	var P_FOREST = 0;
 }
 else if (currentBiome() == "tropic")
 {
 	var MIN_TREES = 1000;
 	var MAX_TREES = 6000;
 	var P_FOREST = 0.52;
 }
 else
 {
 	var MIN_TREES = 500;
 	var MAX_TREES = 3000;
 	var P_FOREST = 0.7;
 }
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 var numForest = totalTrees * P_FOREST;
 var numStragglers = totalTrees * (1.0 - P_FOREST);
 
 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
 );
 
 log("Creating small stone quarries...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 0, clRock, 10, clHill, 1), stayClasses(clLand, 5)],
 	scaleByMapSize(4,16), 100
 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 0, clMetal, 10, clRock, 5, clHill, 1), stayClasses(clLand, 5)],
 	scaleByMapSize(4,16), 100
 );
 
 RMS.SetProgress(65);
 
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockMedium, 1,3, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 5)],
 	scaleByMapSize(16, 262), 50
 );
 
 log("Creating large decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 5)],
 	scaleByMapSize(8, 131), 50
 );
 
 RMS.SetProgress(70);
 
 log("Creating deer...");
 group = new SimpleGroup(
 	[new SimpleObject(oMainHuntableAnimal, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 0, clHill, 1, clFood, 20), stayClasses(clLand, 5)],
 	3 * numPlayers, 50
 );
 
 RMS.SetProgress(75);
 
 log("Creating sheep...");
 group = new SimpleGroup(
 	[new SimpleObject(oSecondaryHuntableAnimal, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 0, clHill, 1, clFood, 20), stayClasses(clLand, 5)],
 	3 * numPlayers, 50
 );
 
 log("Creating fruit bush...");
 group = new SimpleGroup(
 	[new SimpleObject(oFruitBush, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 8, clHill, 1, clFood, 20), stayClasses(clLand, 5)],
 	randIntInclusive(1, 4) * numPlayers + 2, 50
 );
 
 log("Creating fish...");
 group = new SimpleGroup(
 	[new SimpleObject(oFish, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clLand, 4, clForest, 2, clPlayer, 2, clHill, 2, clFood, 20),
 	25 * numPlayers, 60
 );
 
 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")
 	planetm = 8;
 
 log("Creating small grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)]
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clHill, 2, clPlayer, 2, clDirt, 0), stayClasses(clLand, 6)],
 	planetm * 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,
 	[avoidClasses(clHill, 2, clPlayer, 2, clDirt, 1, clForest, 0), stayClasses(clLand, 5)],
 	planetm * 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,
 	[avoidClasses(clHill, 1, clPlayer, 1, clDirt, 1), stayClasses(clLand, 6)],
 	planetm * scaleByMapSize(13, 200), 50
 );
 
 setSkySet(pickRandom(["cirrus", "cumulus", "sunny"]));
 setSunRotation(randFloat(0, TWO_PI));
 setSunElevation(randFloat(PI/ 5, PI / 3));
 setWaterWaviness(2);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/kerala.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/kerala.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/kerala.js	(revision 20301)
@@ -1,421 +1,392 @@
 RMS.LoadLibrary("rmgen");
 
 const tGrass = ["tropic_grass_c", "tropic_grass_c", "tropic_grass_c", "tropic_grass_c", "tropic_grass_plants", "tropic_plants", "tropic_plants_b"];
 const tGrassA = "tropic_plants_c";
 const tGrassB = "tropic_plants_c";
 const tGrassC = "tropic_grass_c";
 const tForestFloor = "tropic_grass_plants";
 const tCliff = ["tropic_cliff_a", "tropic_cliff_a", "tropic_cliff_a", "tropic_cliff_a_plants"];
 const tPlants = "tropic_plants";
 const tRoad = "tropic_citytile_a";
 const tRoadWild = "tropic_citytile_plants";
 const tShoreBlend = "tropic_beach_dry_plants";
 const tShore = "tropic_beach_dry";
 const tWater = "tropic_beach_wet";
 
 const oTree = "gaia/flora_tree_toona";
 const oPalm = "gaia/flora_tree_palm_tropic";
 const oStoneLarge = "gaia/geology_stonemine_tropic_quarry";
 const oStoneSmall = "gaia/geology_stone_tropic_a";
 const oMetalLarge = "gaia/geology_metal_tropic_slabs";
 const oFish = "gaia/fauna_fish";
 const oDeer = "gaia/fauna_deer";
 const oSheep = "gaia/fauna_tiger";
 const oBush = "gaia/flora_bush_berry";
 
 const aRockLarge = "actor|geology/stone_granite_large.xml";
 const aRockMedium = "actor|geology/stone_granite_med.xml";
 const aBush1 = "actor|props/flora/plant_tropic_a.xml";
 const aBush2 = "actor|props/flora/plant_lg.xml";
 const aBush3 = "actor|props/flora/plant_tropic_large.xml";
 
 const pForestD = [tForestFloor + TERRAIN_SEPARATOR + oTree, tForestFloor];
 const pForestP = [tForestFloor + TERRAIN_SEPARATOR + oPalm, tForestFloor];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clMountains = createTileClass();
 
 var playerIDs = sortAllPlayers();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(0.45 + 0.2 * (i % 2));
 	var fz = fractionToTiles((i + 1) / (numPlayers + 1));
 	var ix = round(fx);
 	var iz = round(fz);
 	addCivicCenterAreaToClass(ix, iz, clPlayer);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	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);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 		placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 	var hillSize = PI * radius * radius;
 	// create starting trees
 	var num = floor(hillSize / 60);
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(12, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oTree, num, num, 0,3)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 }
 
 RMS.SetProgress(15);
 
 const waterPos = 0.31;
 const mountainPos = 0.69;
 
 paintRiver({
 	"horizontal": false,
 	"parallel": false,
 	"position": 0,
 	"width": 2 * waterPos,
 	"fadeDist": 0.025,
 	"deviation": 0,
 	"waterHeight": -5,
 	"landHeight": 3,
 	"meanderShort": 20,
 	"meanderLong": 0,
 	"waterFunc": (ix, iz, height) => {
 		addToClass(ix, iz, clWater);
 	},
 	"landFunc": (ix, iz, shoreDist1, shoreDist2) => {
 		if (ix > mountainPos * mapSize)
 			addToClass(ix, iz, clMountains)
 	}
 });
 
 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);
 paintTerrainBasedOnHeight(0, 1, 1, tShore);
 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;
 
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 var numForest = totalTrees * P_FOREST;
 var numStragglers = totalTrees * (1.0 - P_FOREST);
 
 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
 );
 
 log("Creating small stone quarries...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clRock, 10, clHill, 1),
 	scaleByMapSize(4,16), 100
 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 1),
 	scaleByMapSize(4,16), 100
 );
 
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockMedium, 1,3, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0),
 	3*scaleByMapSize(16, 262), 50
 );
 
 log("Creating large decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0),
 	3*scaleByMapSize(8, 131), 50
 );
 
 log("Creating small grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aBush1, 1,2, 0,1, -PI/8,PI/8)]
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 2, clHill, 2, clPlayer, 2, clDirt, 0),
 	8 * scaleByMapSize(13, 200)
 );
 
 RMS.SetProgress(90);
 
 log("Creating large grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aBush2, 2,4, 0,1.8, -PI/8,PI/8), new SimpleObject(aBush1, 3,6, 1.2,2.5, -PI/8,PI/8)]
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clHill, 2, clPlayer, 2, clDirt, 1, clForest, 0),
 	8 * scaleByMapSize(13, 200)
 );
 
 RMS.SetProgress(95);
 
 log("Creating bushes...");
 group = new SimpleGroup(
 	[new SimpleObject(aBush3, 1,2, 0,2), new SimpleObject(aBush2, 2,4, 0,2)]
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 1, clHill, 1, clPlayer, 1, clDirt, 1),
 	8 * scaleByMapSize(13, 200), 50
 );
 
 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(
 	[new SimpleObject(oDeer, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 0, clPlayer, 10, clHill, 1, clFood, 20),
 	3 * numPlayers, 50
 );
 
 RMS.SetProgress(75);
 
 log("Creating berry bush...");
 group = new SimpleGroup(
 	[new SimpleObject(oBush, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 6, clForest, 0, clPlayer, 20, clHill, 1, clFood, 10),
 	randIntInclusive(1, 4) * numPlayers + 2, 50
 );
 
 log("Creating sheep...");
 group = new SimpleGroup(
 	[new SimpleObject(oSheep, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 0, clPlayer, 22, clHill, 1, clFood, 20),
 	3 * numPlayers, 50
 );
 
 log("Creating fish...");
 group = new SimpleGroup(
 	[new SimpleObject(oFish, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clFood, 20), stayClasses(clWater, 6)],
 	25 * numPlayers, 60
 );
 
 setSunColor(0.6, 0.6, 0.6);
 setSunElevation(PI/ 3);
 
 setWaterColor(0.524,0.734,0.839);
 setWaterTint(0.369,0.765,0.745);
 setWaterWaviness(1.0);
 setWaterType("ocean");
 setWaterMurkiness(0.35);
 
 setFogFactor(0.4);
 setFogThickness(0.2);
 
 setPPEffect("hdr");
 setPPContrast(0.7);
 setPPSaturation(0.65);
 setPPBloom(0.6);
 
 setSkySet("cirrus");
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/lorraine_plain.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/lorraine_plain.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/lorraine_plain.js	(revision 20301)
@@ -1,433 +1,442 @@
 RMS.LoadLibrary("rmgen");
 
 const tGrass = ["temp_grass", "temp_grass", "temp_grass_d"];
 const tGrassPForest = "temp_plants_bog";
 const tGrassDForest = "temp_plants_bog";
 const tGrassA = "temp_grass_plants";
 const tGrassB = "temp_plants_bog";
 const tGrassC = "temp_mud_a";
 const tRoad = "temp_road";
 const tRoadWild = "temp_road_overgrown";
 const tGrassPatchBlend = "temp_grass_long_b";
 const tGrassPatch = ["temp_grass_d", "temp_grass_clovers"];
 const tShore = "temp_plants_bog";
 const tWater = "temp_mud_a";
 
 const oBeech = "gaia/flora_tree_euro_beech";
 const oOak = "gaia/flora_tree_oak";
 const oBerryBush = "gaia/flora_bush_berry";
 const oDeer = "gaia/fauna_deer";
 const oRabbit = "gaia/fauna_rabbit";
 const oStoneLarge = "gaia/geology_stonemine_temperate_quarry";
 const oStoneSmall = "gaia/geology_stone_temperate";
 const oMetalLarge = "gaia/geology_metal_temperate_slabs";
 
 const aGrass = "actor|props/flora/grass_soft_small_tall.xml";
 const aGrassShort = "actor|props/flora/grass_soft_large.xml";
 const aRockLarge = "actor|geology/stone_granite_med.xml";
 const aRockMedium = "actor|geology/stone_granite_med.xml";
 const aReeds = "actor|props/flora/reeds_pond_lush_a.xml";
 const aLillies = "actor|props/flora/water_lillies.xml";
 const aBushMedium = "actor|props/flora/bush_medit_me.xml";
 const aBushSmall = "actor|props/flora/bush_medit_sm.xml";
 
 const pForestB = [tGrassDForest + TERRAIN_SEPARATOR + oBeech, tGrassDForest];
 const pForestO = [tGrassPForest + TERRAIN_SEPARATOR + oOak, tGrassPForest];
 const pForestR = [tGrassDForest + TERRAIN_SEPARATOR + oBeech, tGrassDForest, tGrassDForest + TERRAIN_SEPARATOR + oOak, tGrassDForest, tGrassDForest, tGrassDForest];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clShallow = createTileClass();
 
 var playerIDs = primeSortAllPlayers();
 var playerPos = placePlayersRiver();
+var waterHeight = -4;
 
 var playerX = [];
 var playerZ = [];
 
 for (var i = 0; i < numPlayers; i++)
 {
 	playerZ[i] = 0.25 + 0.5*(i%2);
 	playerX[i] = playerPos[i];
 }
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	// scale radius of player area by map size
 	var radius = scaleByMapSize(15,25);
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 
 	// calculate size based on the radius
 	var size = PI * radius * radius / 4;
 
 	// create the player area
 	var placer = new ClumpPlacer(size, 0.9, 0.5, 10, ix, iz);
 	createArea(placer, paintClass(clPlayer), null);
 
 	// create the city patch
 	var cityRadius = 10;
 	placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tRoadWild, tRoad], [3]);
 	createArea(placer, painter, null);
 
 	placeCivDefaultEntities(fx, fz, id, { 'iberWall': 'towers' });
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oBerryBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = 11;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0), new SimpleObject(aGrass, 2,4, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2), new SimpleObject(aGrass, 2,4, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var num = 3;
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(11, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oOak, num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	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));
-
-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 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));
+
+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);
 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)
 const MIN_TREES = 500;
 const MAX_TREES = 2500;
 const P_FOREST = 0.7;
 
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 var numForest = totalTrees * P_FOREST;
 var numStragglers = totalTrees * (1.0 - P_FOREST);
 
 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
 );
 
 log("Creating small stone quarries...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clWater, 0, clForest, 1, clPlayer, 15, clRock, 10, clHill, 1)],
 	scaleByMapSize(4,16), 100
 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clWater, 0, clForest, 1, clPlayer, 15, clMetal, 10, clRock, 5, clHill, 1)],
 	scaleByMapSize(4,16), 100
 );
 
 RMS.SetProgress(86);
 
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockMedium, 1,3, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0),
 	scaleByMapSize(16, 262), 50
 );
 
 log("Creating large decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0),
 	scaleByMapSize(8, 131), 50
 );
 
 log("Creating deer...");
 group = new SimpleGroup(
 	[new SimpleObject(oDeer, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 0, clForest, 0, clPlayer, 15, clHill, 1, clFood, 20),
 	3 * numPlayers, 50
 );
 
 log("Creating rabbits...");
 group = new SimpleGroup(
 	[new SimpleObject(oRabbit, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 0, clForest, 0, clPlayer, 15, clHill, 1, clFood, 20),
 	3 * numPlayers, 50
 );
 
 log("Creating berry bush...");
 group = new SimpleGroup(
 	[new SimpleObject(oBerryBush, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 0, clPlayer, 15, clHill, 1, clFood, 10),
 	randIntInclusive(1, 4) * numPlayers + 2, 50
 );
 
 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(
 	[new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)]
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 2, clHill, 2, clPlayer, 2, clDirt, 0),
 	scaleByMapSize(13, 200)
 );
 
 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,
 	avoidClasses(clWater, 3, clHill, 2, clPlayer, 2, clDirt, 1, clForest, 0),
 	scaleByMapSize(13, 200)
 );
 
 log("Creating bushes...");
 group = new SimpleGroup(
 	[new SimpleObject(aBushMedium, 1,2, 0,2), new SimpleObject(aBushSmall, 2,4, 0,2)]
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 1, clHill, 1, clPlayer, 1, clDirt, 1),
 	scaleByMapSize(13, 200), 50
 );
 
 log("Creating shallow flora...");
 group = new SimpleGroup(
 	[new SimpleObject(aLillies, 1,2, 0,2), new SimpleObject(aReeds, 2,4, 0,2)]
 );
 createObjectGroupsDeprecated(group, 0,
 	stayClasses(clShallow, 1),
 	60 * scaleByMapSize(13, 200), 80
 );
 
 setSkySet("cirrus");
 setWaterColor(0.1,0.212,0.422);
 setWaterTint(0.3,0.1,0.949);
 setWaterWaviness(3.0);
 setWaterType("lake");
 setWaterMurkiness(0.80);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/migration.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/migration.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/migration.js	(revision 20301)
@@ -1,469 +1,457 @@
 RMS.LoadLibrary("rmgen");
 RMS.LoadLibrary("rmbiome");
 
 setSelectedBiome();
 
 const tMainTerrain = g_Terrains.mainTerrain;
 const tForestFloor1 = g_Terrains.forestFloor1;
 const tForestFloor2 = g_Terrains.forestFloor2;
 const tCliff = g_Terrains.cliff;
 const tTier1Terrain = g_Terrains.tier1Terrain;
 const tTier2Terrain = g_Terrains.tier2Terrain;
 const tTier3Terrain = g_Terrains.tier3Terrain;
 const tHill = g_Terrains.hill;
 const tRoad = g_Terrains.road;
 const tRoadWild = g_Terrains.roadWild;
 const tTier4Terrain = g_Terrains.tier4Terrain;
 const tShore = g_Terrains.shore;
 const tWater = g_Terrains.water;
 
 const oTree1 = g_Gaia.tree1;
 const oTree2 = g_Gaia.tree2;
 const oTree3 = g_Gaia.tree3;
 const oTree4 = g_Gaia.tree4;
 const oTree5 = g_Gaia.tree5;
 const oFruitBush = g_Gaia.fruitBush;
 const oMainHuntableAnimal = g_Gaia.mainHuntableAnimal;
 const oFish = g_Gaia.fish;
 const oSecondaryHuntableAnimal = g_Gaia.secondaryHuntableAnimal;
 const oStoneLarge = g_Gaia.stoneLarge;
 const oStoneSmall = g_Gaia.stoneSmall;
 const oMetalLarge = g_Gaia.metalLarge;
 const oWood = "gaia/special_treasure_wood";
 
 const aGrass = g_Decoratives.grass;
 const aGrassShort = g_Decoratives.grassShort;
 const aRockLarge = g_Decoratives.rockLarge;
 const aRockMedium = g_Decoratives.rockMedium;
 const aBushMedium = g_Decoratives.bushMedium;
 const aBushSmall = g_Decoratives.bushSmall;
 
 const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
 const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 const mapArea = mapSize*mapSize;
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clLand = createTileClass();
 
+var landHeight = 3;
+
 var playerIDs = sortAllPlayers();
 
 // place players
 var playerX = [];
 var playerZ = [];
 var playerAngle = [];
 
 var startAngle = PI/2 + PI/14;
 for (var i = 0; i < numPlayers; i++)
 {
 	playerAngle[i] = startAngle - (i+1)*(PI+ PI/7)/(numPlayers+1);
 	playerX[i] = 0.5 + 0.35*cos(playerAngle[i]);
 	playerZ[i] = 0.5 + 0.35*sin(playerAngle[i]);
 }
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var shoreRadius = 4;
 	var elevation = 3;
 
 	var hillSize = PI * radius * radius;
 	// get the x and z in tiles
 	fx = fractionToTiles(playerX[i]);
 	fz = fractionToTiles(playerZ[i]);
 	ix = round(fx);
 	iz = round(fz);
 	// create the hill
 	var placer = new ClumpPlacer(hillSize, 0.80, 0.1, 10, ix, iz);
 	var terrainPainter = new LayeredPainter(
 		[tWater , tShore, tMainTerrain],		// terrains
 		[1, shoreRadius]		// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		elevation,				// elevation
 		shoreRadius				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clPlayer)], null);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tRoadWild, tRoad], [1]);
 	createArea(placer, painter, null);
 
 	placeCivDefaultEntities(fx, fz, id, { 'iberWall': false });
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oFruitBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create woods
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 13;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oWood, 14,14, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 		mAngle = randFloat(0, TWO_PI);
 
 	var mDist = radius - 4;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 	var hillSize = PI * radius * radius;
 	// create starting trees
 	var num = floor(hillSize / 60);
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = 11;
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oTree1, num, num, 0,4)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	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
 );
 RMS.SetProgress(34);
 
 // calculate desired number of trees for map (based on size)
 if (currentBiome() == "savanna")
 {
 	var MIN_TREES = 200;
 	var MAX_TREES = 1250;
 	var P_FOREST = 0.02;
 }
 else if (currentBiome() == "tropic")
 {
 	var MIN_TREES = 1000;
 	var MAX_TREES = 6000;
 	var P_FOREST = 0.6;
 }
 else
 {
 	var MIN_TREES = 500;
 	var MAX_TREES = 3000;
 	var P_FOREST = 0.7;
 }
 
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 var numForest = totalTrees * P_FOREST;
 var numStragglers = totalTrees * (1.0 - P_FOREST);
 
 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
 );
 RMS.SetProgress(50);
 
 log("Creating small stone quarries...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 10, clRock, 10, clHill, 1), stayClasses(clLand, 7)],
 	scaleByMapSize(4,16), 100
 );
 RMS.SetProgress(54);
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 10, clMetal, 10, clRock, 5, clHill, 1), stayClasses(clLand, 7)],
 	scaleByMapSize(4,16), 100
 );
 RMS.SetProgress(58);
 
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockMedium, 1,3, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 6)],
 	scaleByMapSize(16, 262), 50
 );
 RMS.SetProgress(62);
 
 log("Creating large decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 6)],
 	scaleByMapSize(8, 131), 50
 );
 RMS.SetProgress(66);
 
 log("Creating deer...");
 group = new SimpleGroup(
 	[new SimpleObject(oMainHuntableAnimal, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 10, clHill, 1, clFood, 20), stayClasses(clLand, 7)],
 	3 * numPlayers, 50
 );
 RMS.SetProgress(70);
 
 log("Creating sheep...");
 group = new SimpleGroup(
 	[new SimpleObject(oSecondaryHuntableAnimal, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 10, clHill, 1, clFood, 20), stayClasses(clLand, 7)],
 	3 * numPlayers, 50
 );
 RMS.SetProgress(74);
 
 log("Creating fruit bush...");
 group = new SimpleGroup(
 	[new SimpleObject(oFruitBush, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 8, clHill, 1, clFood, 20), stayClasses(clLand, 7)],
 	randIntInclusive(1, 4) * numPlayers + 2, 50
 );
 RMS.SetProgress(78);
 
 log("Creating fish...");
 createObjectGroupsDeprecated(
 	new SimpleGroup([new SimpleObject(oFish, 2,3, 0,2)], true, clFood),
 	0,
 	avoidClasses(clLand, 2, clPlayer, 2, clHill, 0, clFood, 20),
 	25 * numPlayers, 60
 );
 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;
 
 log("Creating small grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)]
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clHill, 2, clPlayer, 2, clDirt, 0), stayClasses(clLand, 6)],
 	planetm * 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,
 	[avoidClasses(clHill, 2, clPlayer, 2, clDirt, 1, clForest, 0), stayClasses(clLand, 6)],
 	planetm * scaleByMapSize(13, 200)
 );
 RMS.SetProgress(94);
 
 log("Creating bushes...");
 group = new SimpleGroup(
 	[new SimpleObject(aBushMedium, 1,2, 0,2), new SimpleObject(aBushSmall, 2,4, 0,2)]
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clHill, 1, clPlayer, 1, clDirt, 1), stayClasses(clLand, 6)],
 	planetm * scaleByMapSize(13, 200), 50
 );
 RMS.SetProgress(98);
 
 setSkySet(pickRandom(["cirrus", "cumulus", "sunny"]));
 setSunRotation(randFloat(0, TWO_PI));
 setSunElevation(randFloat(PI/ 5, PI / 3));
 setWaterWaviness(2);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/northern_lights.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/northern_lights.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/northern_lights.js	(revision 20301)
@@ -1,367 +1,340 @@
 RMS.LoadLibrary("rmgen");
 
 const tSnowA = ["polar_snow_b"];
 const tSnowB = "polar_ice_snow";
 const tSnowC = "polar_ice";
 const tSnowD = "polar_snow_a";
 const tForestFloor = "polar_tundra_snow";
 const tCliff = "polar_snow_rocks";
 const tSnowE = ["polar_snow_glacial"];
 const tRoad = "new_alpine_citytile";
 const tRoadWild = "new_alpine_citytile";
 const tShoreBlend = "alpine_shore_rocks_icy";
 const tShore = "alpine_shore_rocks";
 const tWater = "alpine_shore_rocks";
 
 const oPine = "gaia/flora_tree_pine_w";
 const oStoneLarge = "gaia/geology_stonemine_alpine_quarry";
 const oStoneSmall = "gaia/geology_stone_alpine_a";
 const oMetalLarge = "gaia/geology_metal_alpine_slabs";
 const oFish = "gaia/fauna_fish";
 const oWalrus = "gaia/fauna_walrus";
 const oWolf = "gaia/fauna_wolf_snow";
 
 const aIceberg = "actor|props/special/eyecandy/iceberg.xml";
 
 const pForestD = [tForestFloor + TERRAIN_SEPARATOR + oPine, tForestFloor, tForestFloor];
 const pForestS = [tForestFloor + TERRAIN_SEPARATOR + oPine, tForestFloor, tForestFloor, tForestFloor];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 
 var playerIDs = sortAllPlayers();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	var fx = fractionToTiles((i + 1) / (numPlayers + 1));
 	var fz = fractionToTiles(0.35 + 0.2 * (i % 2));
 	var ix = round(fx);
 	var iz = round(fz);
 	addCivicCenterAreaToClass(ix, iz, clPlayer);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	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);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	// create metal mine
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 	var hillSize = PI * radius * radius;
 	// create starting trees
 	var num = floor(hillSize / 60);
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(12, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oPine, num, num, 0,3)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 }
 
 RMS.SetProgress(15);
 
 paintRiver({
 	"horizontal": true,
 	"parallel": true,
 	"position": 1,
 	"width": 0.62,
 	"fadeDist": 8 / mapSize,
 	"deviation": 0,
 	"waterHeight": -5,
 	"landHeight": 3,
 	"meanderShort": 0,
 	"meanderLong": 0,
 	"waterFunc": (ix, iz, height) => {
 		addToClass(ix, iz, clWater);
 	},
 	"landFunc": (ix, iz, shoreDist1, shoreDist2) => {
 		if (getHeight(ix, iz) < 0.5)
 			addToClass(ix, iz, clWater);
 	}
 });
 
 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)
 );
 
 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);
 
 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;
 
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 var numForest = totalTrees * P_FOREST;
 var numStragglers = totalTrees * (1.0 - P_FOREST);
 
 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
 );
 
 log("Creating small stone quarries...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clRock, 10, clHill, 1),
 	scaleByMapSize(8,32), 100
 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 1),
 	scaleByMapSize(8,32), 100
 );
 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(
 	[new SimpleObject(oWalrus, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 20),
 	3 * numPlayers, 50
 );
 
 RMS.SetProgress(75);
 
 log("Creating sheep...");
 group = new SimpleGroup(
 	[new SimpleObject(oWolf, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 20),
 	3 * numPlayers, 50
 );
 
 log("Creating fish...");
 group = new SimpleGroup(
 	[new SimpleObject(oFish, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clFood, 20), stayClasses(clWater, 6)],
 	25 * numPlayers, 60
 );
 
 setSunColor(0.6, 0.6, 0.6);
 setSunElevation(PI/ 6);
 
 setWaterColor(0.02, 0.17, 0.52);
 setWaterTint(0.494, 0.682, 0.808);
 setWaterMurkiness(0.82);
 setWaterWaviness(0.5);
 setWaterType("ocean");
 
 setFogFactor(0.95);
 setFogThickness(0.09);
 setPPSaturation(0.28);
 setPPEffect("hdr");
 
 setSkySet("fog");
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/persian_highlands.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/persian_highlands.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/persian_highlands.js	(revision 20301)
@@ -1,382 +1,401 @@
 RMS.LoadLibrary("rmgen");
 
 const tCity = "desert_city_tile_pers_dirt";
 
 if (randBool()) // summer
 {
 	var tDirtMain = ["desert_dirt_persia_1", "desert_dirt_persia_2", "grass_field_dry"];
 	var tLakebed1 = ["desert_lakebed_dry_b", "desert_lakebed_dry"];
 	var tLakebed2 = ["desert_lakebed_dry_b", "desert_lakebed_dry", "desert_shore_stones", "desert_shore_stones"];
 	var tCliff = ["desert_cliff_persia_1", "desert_cliff_persia_crumbling"];
 	var tForestFloor = "medit_grass_field_dry";
 	var tRocky = "desert_dirt_persia_rocky";
 	var tRocks = "desert_dirt_persia_rocks";
 	var tGrass = "grass_field_dry";
 }
 else //spring
 {
 	var tDirtMain = ["desert_grass_a", "desert_grass_a", "desert_grass_a", "desert_plants_a"];
 	var tLakebed1 = ["desert_lakebed_dry_b", "desert_lakebed_dry"];
 	var tLakebed2 = "desert_grass_a_sand";
 	var tCliff = ["desert_cliff_persia_1", "desert_cliff_persia_crumbling"];
 	var tForestFloor = "desert_plants_b_persia";
 	var tRocky = "desert_plants_b_persia";
 	var tRocks = "desert_plants_a";
 	var tGrass = "desert_dirt_persia_rocky";
 
 	setTerrainAmbientColor(0.329412, 0.419608, 0.501961);
 }
 
 const oGrapesBush = "gaia/flora_bush_grapes";
 const oCamel = "gaia/fauna_camel";
 const oSheep = "gaia/fauna_sheep";
 const oGoat = "gaia/fauna_goat";
 const oStoneLarge = "gaia/geology_stonemine_desert_badlands_quarry";
 const oStoneSmall = "gaia/geology_stone_desert_small";
 const oMetalLarge = "gaia/geology_metal_desert_slabs";
 const oOak = "gaia/flora_tree_oak";
 
 const aBush1 = "actor|props/flora/bush_desert_a.xml";
 const aBush2 = "actor|props/flora/bush_desert_dry_a.xml";
 const aBush3 = "actor|props/flora/bush_dry_a.xml";
 const aBush4 = "actor|props/flora/plant_desert_a.xml";
 const aBushes = [aBush1, aBush2, aBush3, aBush4];
 const aDecorativeRock = "actor|geology/stone_desert_med.xml";
 
 // terrain + entity (for painting)
 const pForestO = [tForestFloor + TERRAIN_SEPARATOR + oOak, tForestFloor + TERRAIN_SEPARATOR + oOak, tForestFloor, tDirtMain, tDirtMain];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clPatch = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clCP = createTileClass();
 
 initTerrain(tDirtMain);
 
 var [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	// scale radius of player area by map size
 	var radius = scaleByMapSize(15,25);
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 
 	// calculate size based on the radius
 	var size = PI * radius * radius;
 
 	// create the player area
 	var placer = new ClumpPlacer(size, 0.9, 0.5, 10, ix, iz);
 	createArea(placer, paintClass(clPlayer), null);
 
 	// create the city patch
 	var cityRadius = 10;
 	placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tCity, tCity], [3]);
 	createArea(placer, painter, null);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oGrapesBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = 11;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0), new RandomObject(aBushes, 2,4, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2), new RandomObject(aBushes, 2,4, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var num = 3;
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(11, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oOak, num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 }
 
 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)),
 		floor(scaleByMapSize(6, 12)),
 		floor(scaleByMapSize(4, 10)),
 		avoidClasses(clPlayer, 7, clCP, 5, clHill, floor(scaleByMapSize(18, 25))),
 		randIntExclusive(0, mapSize),
 		randIntExclusive(0, mapSize),
 		tCliff,
 		clHill,
-		14
-	);
-}
-
+		14);
 RMS.SetProgress(35);
 
 // calculate desired number of trees for map (based on size)
 const MIN_TREES = 500;
 const MAX_TREES = 2500;
 const P_FOREST = 0.7;
 
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 var numForest = totalTrees * P_FOREST;
 var numStragglers = totalTrees * (1.0 - P_FOREST);
 
 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
 );
 
 log("Creating small stone quarries...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3), 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
 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4), new RandomObject(aBushes, 2,4, 0,2)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 10, clMetal, 10, clRock, 5, clHill, 1, clCP, 1)],
 	scaleByMapSize(2,8), 100
 );
 
 log("Creating centeral 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);
 createObjectGroupsDeprecated(group, 0,
 	stayClasses(clCP, 6),
 	5*scaleByMapSize(5,30), 50
 );
 
 log("Creating small stone quarries...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3), new RandomObject(aBushes, 2,4, 0,2)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	stayClasses(clCP, 6),
 	5*scaleByMapSize(5,30), 50
 );
 
 log("Creating centeral metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4), new RandomObject(aBushes, 2,4, 0,2)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	stayClasses(clCP, 6),
 	5*scaleByMapSize(5,30), 50
 );
 
 RMS.SetProgress(60);
 
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aDecorativeRock, 1,3, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clForest, 0, clPlayer, 0, clHill, 0),
 	scaleByMapSize(16, 262), 50
 );
 
 RMS.SetProgress(65);
 
 log("Creating bushes...");
 group = new SimpleGroup(
 	[new SimpleObject(aBush2, 1,2, 0,1), new SimpleObject(aBush1, 1,3, 0,2)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clForest, 0, clPlayer, 0, clHill, 0),
 	scaleByMapSize(8, 131), 50
 );
 
 RMS.SetProgress(70);
 
 log("Creating goat...");
 group = new SimpleGroup(
 	[new SimpleObject(oGoat, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 1, clHill, 1, clFood, 20, clCP, 2),
 	3 * numPlayers, 50
 );
 
 log("Creating sheep...");
 group = new SimpleGroup(
 	[new SimpleObject(oSheep, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 1, clHill, 1, clFood, 20, clCP, 2),
 	3 * numPlayers, 50
 );
 
 log("Creating grape bush...");
 group = new SimpleGroup(
 	[new SimpleObject(oGrapesBush, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 20, clHill, 1, clFood, 10, clCP, 2),
 	randIntInclusive(1, 4) * numPlayers + 2, 50
 );
 
 log("Creating camels...");
 group = new SimpleGroup(
 	[new SimpleObject(oCamel, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	stayClasses(clCP, 2),
 	3 * numPlayers, 50
 );
 
 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);
 setSunRotation(-1.86532);
 
 setFogFactor(0.2);
 setFogThickness(0.0);
 setFogColor(0.852, 0.746, 0.493);
 
 setPPEffect("hdr");
 setPPContrast(0.75);
 setPPSaturation(0.45);
 setPPBloom(0.3);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/pyrenean_sierra.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/pyrenean_sierra.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/pyrenean_sierra.js	(revision 20301)
@@ -1,812 +1,826 @@
 RMS.LoadLibrary("rmgen");
 
 // Some functions
 // This is the basic SmoothElevationPainter with a random component thrown in.
 function SemiRandomElevationPainter(elevation, blendRadius,roughness)
 {
 	this.elevation = elevation;
 	this.blendRadius = blendRadius;
 	if (!roughness)
 		this.roughness = 5;
 	else
 		this.roughness = roughness;
 }
 
 SemiRandomElevationPainter.prototype.checkInArea = function(areaID, x, z)
 {
 	// Check given tile and its neighbors
 	return (
 			(g_Map.inMapBounds(x, z) && g_Map.area[x][z] == areaID)
 			|| (g_Map.inMapBounds(x-1, z) && g_Map.area[x-1][z] == areaID)
 			|| (g_Map.inMapBounds(x, z-1) && g_Map.area[x][z-1] == areaID)
 			|| (g_Map.inMapBounds(x-1, z-1) && g_Map.area[x-1][z-1] == areaID)
 			);
 };
 
 SemiRandomElevationPainter.prototype.paint = function(area)
 {
 	var pointQ = [];
 	var pts = area.points;
 	var heightPts = [];
 
 	var mapSize = getMapSize()+1;
 
 	var saw = [];
 	var dist = [];
 	var gotHeightPt = [];
 	var newHeight = [];
 
 	// init typed arrays
 	for (var i = 0; i < mapSize; ++i)
 	{
 		saw[i] = new Uint8Array(mapSize);			// bool / uint8
 		dist[i] = new Uint16Array(mapSize);			// uint16
 		gotHeightPt[i] = new Uint8Array(mapSize);	// bool / uint8
 		newHeight[i] = new Float32Array(mapSize);	// float32
 	}
 
 	var length = pts.length;
 	var areaID = area.getID();
 
 	// get a list of all points
 	for (var i=0; i < length; i++)
 	{
 		var x = pts[i].x;
 		var z = pts[i].z;
 
 		for (var dx=-1; dx <= 2; dx++)
 		{
 			var nx = x+dx;
 			for (var dz=-1; dz <= 2; dz++)
 			{
 				var nz = z+dz;
 
 				if (g_Map.validH(nx, nz) && !gotHeightPt[nx][nz])
 				{
 					gotHeightPt[nx][nz] = 1;
 					heightPts.push(new PointXZ(nx, nz));
 					newHeight[nx][nz] = g_Map.height[nx][nz];
 				}
 			}
 		}
 	}
 
 	// push edge points
 	for (var i=0; i < length; i++)
 	{
 		var x = pts[i].x;
 		var z = pts[i].z;
 		for (var dx=-1; dx <= 2; dx++)
 		{
 			var nx = x+dx;
 			for (var dz=-1; dz <= 2; dz++)
 			{
 				var nz = z+dz;
 
 				if (g_Map.validH(nx, nz) && !this.checkInArea(areaID, nx, nz) && !saw[nx][nz])
 				{
 					saw[nx][nz]= 1;
 					dist[nx][nz] = 0;
 					pointQ.push(new PointXZ(nx, nz));
 				}
 			}
 		}
 	}
 
 	// do BFS inwards to find distances to edge
 	while(pointQ.length)
 	{
 		var pt = pointQ.shift();
 		var px = pt.x;
 		var pz = pt.z;
 		var d = dist[px][pz];
 
 		// paint if in area
 		if (g_Map.validH(px, pz) && this.checkInArea(areaID, px, pz))
 		{
 			if (d <= this.blendRadius)
 			{
 				var a = (d-1) / this.blendRadius;
 				newHeight[px][pz] += a*this.elevation + randFloat(-this.roughness,this.roughness);
 			}
 			else
 			{	// also happens when blendRadius == 0
 				newHeight[px][pz] += this.elevation + randFloat(-this.roughness,this.roughness);
 			}
 		}
 		// enqueue neighbours
 		for (var dx=-1; dx <= 1; dx++)
 		{
 			var nx = px+dx;
 			for (var dz=-1; dz <= 1; dz++)
 			{
 				var nz = pz+dz;
 
 				if (g_Map.validH(nx, nz) && this.checkInArea(areaID, nx, nz) && !saw[nx][nz])
 				{
 					saw[nx][nz] = 1;
 					dist[nx][nz] = d+1;
 					pointQ.push(new PointXZ(nx, nz));
 				}
 			}
 		}
 	}
 
 	length = heightPts.length;
 
 	// smooth everything out
 	for (var i = 0; i < length; ++i)
 	{
 		var pt = heightPts[i];
 		var px = pt.x;
 		var pz = pt.z;
 
 		if (this.checkInArea(areaID, px, pz))
 		{
 			var sum = 8 * newHeight[px][pz];
 			var count = 8;
 
 			for (var dx=-1; dx <= 1; dx++)
 			{
 				var nx = px+dx;
 				for (var dz=-1; dz <= 1; dz++)
 				{
 					var nz = pz+dz;
 
 					if (g_Map.validH(nx, nz))
 					{
 						sum += newHeight[nx][nz];
 						count++;
 					}
 				}
 			}
 
 			g_Map.height[px][pz] = sum/count;
 		}
 	}
 };
 
 TILE_CENTERED_HEIGHT_MAP = true;
 
 const tGrassSpecific = ["new_alpine_grass_d","new_alpine_grass_d", "new_alpine_grass_e"];
 const tGrass = ["new_alpine_grass_d", "new_alpine_grass_b", "new_alpine_grass_e"];
 const tGrassMidRange = ["new_alpine_grass_b", "alpine_grass_a"];
 const tGrassHighRange = ["new_alpine_grass_a", "alpine_grass_a", "alpine_grass_rocky"];
 const tHighRocks = ["alpine_cliff_b", "alpine_cliff_c","alpine_cliff_c", "alpine_grass_rocky"];
 const tSnowedRocks = ["alpine_cliff_b", "alpine_cliff_snow"];
 const tTopSnow = ["alpine_snow_rocky","alpine_snow_a"];
 const tTopSnowOnly = ["alpine_snow_a"];
 
 const tDirtyGrass = ["new_alpine_grass_d","alpine_grass_d","alpine_grass_c", "alpine_grass_b"];
 const tLushGrass = ["new_alpine_grass_a","new_alpine_grass_d"];
 
 const tMidRangeCliffs = ["alpine_cliff_b","alpine_cliff_c"];
 const tHighRangeCliffs = ["alpine_mountainside","alpine_cliff_snow" ];
 const tPass = ["alpine_cliff_b", "alpine_cliff_c", "alpine_grass_rocky", "alpine_grass_rocky", "alpine_grass_rocky"];
 
 const tSand = ["beach_c", "beach_d"];
 const tSandTransition = ["beach_scrub_50_"];
 const tWater = ["sand_wet_a","sand_wet_b","sand_wet_b","sand_wet_b"];
 
 const tGrassLandForest = "alpine_forrestfloor";
 const tGrassLandForest2 = "alpine_grass_d";
 const tForestTransition = ["new_alpine_grass_d", "new_alpine_grass_b","alpine_grass_d"];
 
 const tRoad = "new_alpine_citytile";
 const tRoadWild = "new_alpine_citytile";
 
 const oBeech = "gaia/flora_tree_euro_beech";
 const oPine = "gaia/flora_tree_aleppo_pine";
 const oBerryBush = "gaia/flora_bush_berry";
 const oDeer = "gaia/fauna_deer";
 const oFish = "gaia/fauna_fish";
 const oRabbit = "gaia/fauna_rabbit";
 const oStoneLarge = "gaia/geology_stonemine_alpine_quarry";
 const oStoneSmall = "gaia/geology_stone_alpine_a";
 const oMetalLarge = "gaia/geology_metal_alpine_slabs";
 
 const aGrass = "actor|props/flora/grass_soft_small_tall.xml";
 const aGrassShort = "actor|props/flora/grass_soft_large.xml";
 const aRockLarge = "actor|geology/stone_granite_med.xml";
 const aRockMedium = "actor|geology/stone_granite_med.xml";
 const aBushMedium = "actor|props/flora/bush_medit_me.xml";
 const aBushSmall = "actor|props/flora/bush_medit_sm.xml";
 
 const pForestLand = [tGrassLandForest + TERRAIN_SEPARATOR + oPine,tGrassLandForest + TERRAIN_SEPARATOR + oBeech,
 				   tGrassLandForest2 + TERRAIN_SEPARATOR + oPine,tGrassLandForest2 + TERRAIN_SEPARATOR + oBeech,
 				   tGrassLandForest,tGrassLandForest2,tGrassLandForest2,tGrassLandForest2];
 const pForestLandLight = [tGrassLandForest + TERRAIN_SEPARATOR + oPine,tGrassLandForest + TERRAIN_SEPARATOR + oBeech,
 				   tGrassLandForest2 + TERRAIN_SEPARATOR + oPine,tGrassLandForest2 + TERRAIN_SEPARATOR + oBeech,
 				   tGrassLandForest,tGrassLandForest2,tForestTransition,tGrassLandForest2,
 					tGrassLandForest,tForestTransition,tGrassLandForest2,tForestTransition,
 						tGrassLandForest2,tGrassLandForest2,tGrassLandForest2,tGrassLandForest2];
 const pForestLandVeryLight = [ tGrassLandForest2 + TERRAIN_SEPARATOR + oPine,tGrassLandForest2 + TERRAIN_SEPARATOR + oBeech,
 						tForestTransition,tGrassLandForest2,tForestTransition,tForestTransition,tForestTransition,
 						tGrassLandForest,tForestTransition,tGrassLandForest2,tForestTransition,
 						tGrassLandForest2,tGrassLandForest2,tGrassLandForest2,tGrassLandForest2];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 
 var clDirt = createTileClass();
 var clLush = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clPass = createTileClass();
 var clPyrenneans = createTileClass();
 var clPass = createTileClass();
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 
 // Initial Terrain Creation
 // I'll use very basic noised sinusoidal functions to give the terrain a way aspect
 // It looks like we can't go higher than ≈ 75. Given this I'll lower the ground
 
 const baseHeight = -6;
 setWaterHeight(8);
 
 // let's choose the angle of the pyreneans
 var MoutainAngle = randFloat(0,TWO_PI);
 var lololo = randFloat(-PI/12,-PI/12);	// used by oceans
 
 var baseHeights = [];
 for (var ix = 0; ix < mapSize; ix++)
 {
 	baseHeights.push([]);
 	for (var iz = 0; iz < mapSize; iz++)
 	{
 		if (g_Map.inMapBounds(ix,iz))
 		{
 			placeTerrain(ix, iz, tGrass);
 			setHeight(ix,iz,baseHeight +randFloat(-1,1) + scaleByMapSize(1,3)*(cos(ix/scaleByMapSize(5,30))+sin(iz/scaleByMapSize(5,30))));
 			baseHeights[ix].push( baseHeight +randFloat(-1,1) + scaleByMapSize(1,3)*(cos(ix/scaleByMapSize(5,30))+sin(iz/scaleByMapSize(5,30)))  );
 		}
 		else
 			baseHeights[ix].push(-100);
 	}
 }
 
 var playerIDs = primeSortAllPlayers();
 
 // place players
 var playerX = [];
 var playerZ = [];
 var playerAngle = [];
 
 for (var i = 0; i < numPlayers; i++)
 {
 	if ( i%2 == 1)
 		playerAngle[i] = MoutainAngle+lololo + PI/2 + i/numPlayers*(PI/3) + (1-i/numPlayers)*(-PI/3);
 	else
 		playerAngle[i] = MoutainAngle + lololo - PI/2 + (i+1)/numPlayers*(PI/3) + (1-(i+1)/numPlayers)*(-PI/3);
 	playerX[i] = 0.5 + 0.35*cos(playerAngle[i]);
 	playerZ[i] = 0.5 + 0.35*sin(playerAngle[i]);
 }
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	ix = round(fx);
 	iz = round(fz);
 	addCivicCenterAreaToClass(ix, iz, clPlayer);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	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);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oBerryBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 	var hillSize = PI * radius * radius;
 	// create starting trees
 	var num = floor(hillSize / 100);
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(11, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oPine, num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 RMS.SetProgress(30);
 
 log ("Creating the pyreneans...");
 
 // This is the basic orientation of the pyreneans
 var MountainStartX = fractionToTiles(0.5) + cos(MoutainAngle)*fractionToTiles(0.34);
 var MountainStartZ = fractionToTiles(0.5) + sin(MoutainAngle)*fractionToTiles(0.34);
 var MountainEndX = fractionToTiles(0.5) - cos(MoutainAngle)*fractionToTiles(0.34);
 var MountainEndZ = fractionToTiles(0.5) - sin(MoutainAngle)*fractionToTiles(0.34);
 var MountainHeight = scaleByMapSize(50,65);
 // Number of peaks
 var NumOfIterations = scaleByMapSize(100,1000);
 
 var randomNess = randFloat(-scaleByMapSize(1,12),scaleByMapSize(1,12));
 
 for (var i = 0; i < NumOfIterations; i++)
 {
 	RMS.SetProgress(45 * i/NumOfIterations + 30 * (1-i/NumOfIterations));
 
 	var position = i/NumOfIterations;
 	var width = scaleByMapSize(15,55);
 
 	var randHeight2 = randFloat(0,10) + MountainHeight;
 
 	for (var dist = 0; dist < width*3; dist++)
 	{
 		var okDist = dist/3;
 		var S1x = round((MountainStartX * (1-position) + MountainEndX*position) + randomNess*cos(position*3.14*4) + cos(MoutainAngle+PI/2)*okDist);
 		var S1z = round((MountainStartZ * (1-position) + MountainEndZ*position) + randomNess*sin(position*3.14*4) + sin(MoutainAngle+PI/2)*okDist);
 		var S2x = round((MountainStartX * (1-position) + MountainEndX*position) + randomNess*cos(position*3.14*4) + cos(MoutainAngle-PI/2)*okDist);
 		var S2z = round((MountainStartZ * (1-position) + MountainEndZ*position) + randomNess*sin(position*3.14*4) + sin(MoutainAngle-PI/2)*okDist);
 
 		// complicated sigmoid
 		// Ranges is 0-1, FormX is 0-1 too.
 		var FormX = (-2*(1-okDist/width)+1.9) - 4*(2*(1-okDist/width)-randFloat(0.9,1.1))*(2*(1-okDist/width)-randFloat(0.9,1.1))*(2*(1-okDist/width)-randFloat(0.9,1.1));
 		var Formula = (1/(1 + Math.exp(FormX)));
 
 		// If we're too far from the border, we flatten
 		Formula *= (0.2 - Math.max(0,abs(0.5 - position) - 0.3)) * 5;
 
 		var randHeight = randFloat(-9,9) * Formula;
 
 		var height = baseHeights[S1x][S1z];
 		setHeight(S1x,S1z, height + randHeight2 * Formula + randHeight );
 		var height = baseHeights[S2x][S2z];
 		setHeight(S2x,S2z, height + randHeight2 * Formula + randHeight );
 		if (getHeight(S1x,S1z) > 15)
 			addToClass(S1x,S1z, clPyrenneans);
 		if (getHeight(S2x,S2z) > 15)
 			addToClass(S2x,S2z, clPyrenneans);
 	}
 }
 // Allright now slight smoothing (decreasing with height)
 for (var ix = 1; ix < mapSize-1; ix++)
 {
 	for (var iz = 1; iz < mapSize-1; iz++)
 	{
 		if (g_Map.inMapBounds(ix,iz) && checkIfInClass(ix,iz,clPyrenneans) ) {
 			var NB = getNeighborsHeight(ix,iz);
 			var index = 9/(1 + Math.max(0,getHeight(ix,iz)/7));
 			setHeight(ix,iz, (getHeight(ix,iz)*(9-index) + NB*index)/9 );
 		}
 	}
 }
 RMS.SetProgress(48);
 
 // Okay so the mountains are pretty much here.
 // Making the passes
 
 var passWidth = scaleByMapSize(15,100) /1.8;
 var S1x = round((MountainStartX * (0.35) + MountainEndX*0.65) + cos(MoutainAngle+PI/2)*passWidth);
 var S1z = round((MountainStartZ * (0.35) + MountainEndZ*0.65) + sin(MoutainAngle+PI/2)*passWidth);
 var S2x = round((MountainStartX * (0.35) + MountainEndX*0.65) + cos(MoutainAngle-PI/2)*passWidth);
 var S2z = round((MountainStartZ * (0.35) + MountainEndZ*0.65) + sin(MoutainAngle-PI/2)*passWidth);
 PassMaker(S1x, S1z, S2x, S2z, 4, 7, (getHeight(S1x,S1z) + getHeight(S2x,S2z))/2.0, MountainHeight-25, 2, clPass);
 
 S1x = round((MountainStartX * (0.65) + MountainEndX*0.35) + cos(MoutainAngle+PI/2)*passWidth);
 S1z = round((MountainStartZ * (0.65) + MountainEndZ*0.35) + sin(MoutainAngle+PI/2)*passWidth);
 S2x = round((MountainStartX * (0.65) + MountainEndX*0.35) + cos(MoutainAngle-PI/2)*passWidth);
 S2z = round((MountainStartZ * (0.65) + MountainEndZ*0.35) + sin(MoutainAngle-PI/2)*passWidth);
 PassMaker(S1x, S1z, S2x, S2z, 4, 7, (getHeight(S1x,S1z) + getHeight(S2x,S2z))/2.0, MountainHeight-25, 2, clPass);
 
 RMS.SetProgress(50);
 
 // Smoothing the mountains
 for (var ix = 1; ix < mapSize-1; ix++)
 {
 	for (var iz = 1; iz < mapSize-1; iz++)
 	{
 		if ( g_Map.inMapBounds(ix,iz) && checkIfInClass(ix,iz,clPyrenneans) ) {
 			var NB = getNeighborsHeight(ix,iz);
 			var index = 9/(1 + Math.max(0,(getHeight(ix,iz)-10)/7));
 			setHeight(ix,iz, (getHeight(ix,iz)*(9-index) + NB*index)/9 );
 			baseHeights[ix][iz] = (getHeight(ix,iz)*(9-index) + NB*index)/9;
 		}
 	}
 }
 
 log ("creating Oceans");
 // ALlright for hacky reasons I can't use a smooth Elevation Painter, that wouldn't work.
 // I'll use a harsh one, and then smooth it out
 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++)
 {
 	for (var iz = 1; iz < mapSize-1; iz++)
 	{
 		if ( g_Map.inMapBounds(ix,iz) && getTileClass(clWater).countInRadius(ix,iz,5,true) > 0 ) {
 			// Allright smoothing
 			// I'll have to hack again.
 
 			var averageHeight = 0;
 			var size = 5;
 			if (getTileClass(clPyrenneans).countInRadius(ix,iz,1,true) > 0)
 				size = 1;
 			else if (getTileClass(clPyrenneans).countInRadius(ix,iz,2,true) > 0)
 				size = 2;
 			else if (getTileClass(clPyrenneans).countInRadius(ix,iz,3,true) > 0)
 				size = 3;
 			else if (getTileClass(clPyrenneans).countInRadius(ix,iz,4,true) > 0)
 				size = 4;
 			var todivide = 0;
 			for (var xx = -size; xx <= size;xx++)
 				for (var yy = -size; yy <= size;yy++) {
 					if (g_Map.inMapBounds(ix + xx,iz + yy) && (xx != 0 || yy != 0)){
 						averageHeight += getHeight(ix + xx,iz + yy) / (abs(xx)+abs(yy));
 						todivide += 1/(abs(xx)+abs(yy));
 					}
 				}
 			averageHeight += getHeight(ix,iz)*2;
 			averageHeight /= (todivide+2);
 
 			setHeight(ix,iz, averageHeight );
 			//baseHeights[ix][iz] = averageHeight;
 		}
 		if ( g_Map.inMapBounds(ix,iz) && getTileClass(clWater).countInRadius(ix,iz,4,true) > 0 && getTileClass(clWater).countInRadius(ix,iz,4) > 0 )
 			setHeight(ix,iz, getHeight(ix,iz) + randFloat(-1,1));
 	}
 }
 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...");
 var num = scaleByMapSize(80,400);
 
 var group = new SimpleGroup([new SimpleObject(oPine, 1,2, 1,3),new SimpleObject(oBeech, 1,2, 1,3)], true, clForest);
 createObjectGroupsDeprecated(group, 0,  avoidClasses(clWater, 3, clForest, 1, clPlayer, 8,clPyrenneans, 1), num, 20 );
 
 log("Painting the map");
 
 var terrainGrass = createTerrain(tGrass);
 var terrainGrassMidRange = createTerrain(tGrassMidRange);
 var terrainGrassHighRange = createTerrain(tGrassHighRange);
 var terrainRocks = createTerrain(tHighRocks);
 var terrainRocksSnow = createTerrain(tSnowedRocks);
 var terrainTopSnow = createTerrain(tTopSnow);
 var terrainTopSnowOnly = createTerrain(tTopSnowOnly);
 var terrainMidRangeCliff = createTerrain(tMidRangeCliffs);
 var terrainHighRangeCliff = createTerrain(tHighRangeCliffs);
 var terrainPass = createTerrain(tPass);
 var terrainSand = createTerrain(tSand);
 var terrainSandTransition = createTerrain(tSandTransition);
 var terrainWater = createTerrain(tWater);
 
 for (var x = 0; x < mapSize; x++) {
 	for (var z = 0; z < mapSize; z++) {
 		var height = getHeight(x,z);
 		var heightDiff = getHeightDifference(x,z);
 		if (getTileClass(clPyrenneans).countInRadius(x,z,2,true) > 0) {
 			if (height < 6) {
 				if (heightDiff < 5)
 					terrainGrass.place(x,z);
 				else
 					terrainMidRangeCliff.place(x,z);
 			} else if (height >= 6 && height < 18) {
 				if (heightDiff < 8)
 					terrainGrassMidRange.place(x,z);
 				else
 					terrainMidRangeCliff.place(x,z);
 			} else if (height >= 18 && height < 30) {
 				if (heightDiff < 8)
 					terrainGrassHighRange.place(x,z);
 				else
 					terrainMidRangeCliff.place(x,z);
 			} else if (height >= 30 && height < MountainHeight-20) {
 				if (heightDiff < 8)
 					terrainRocks.place(x,z);
 				else
 					terrainHighRangeCliff.place(x,z);
 			} else if (height >= MountainHeight-20 && height < MountainHeight-10) {
 				if (heightDiff < 7)
 					terrainRocksSnow.place(x,z);
 				else
 					terrainHighRangeCliff.place(x,z);
 			} else if (height >= MountainHeight-10) {
 				if (heightDiff < 6)
 					terrainTopSnowOnly.place(x,z);
 				else
 					terrainTopSnow.place(x,z);
 			}
 			if (height >= 30 && getTileClass(clPass).countInRadius(x,z,2,true) > 0)
 				if (heightDiff < 5)
 					terrainPass.place(x,z);
 		}
 		if (height > -14 &&  height <= -2 && getTileClass(clWater).countInRadius(x,z,2,true) > 0) {
 			if (heightDiff < 2.5)
 				terrainSand.place(x,z);
 			else
 				terrainMidRangeCliff.place(x,z);
 		} else if (height > -14 && height <= 0 && getTileClass(clWater).countInRadius(x,z,3,true) > 0) {
 			if (heightDiff < 2.5)
 				terrainSandTransition.place(x,z);
 			else
 				terrainMidRangeCliff.place(x,z);
 		} else if (height <= -14) {
 			terrainWater.place(x,z);
 		}
 	}
 }
 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);
 
 // making more in dirt areas so as to appear different
 log("Creating small grass tufts...");
 var group = new SimpleGroup( [new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)] );
 createObjectGroupsDeprecated(group, 0, avoidClasses(clWater, 2, clHill, 2, clPlayer, 5, clDirt, 0, clPyrenneans,2), scaleByMapSize(13, 200) );
 createObjectGroupsDeprecated(group, 0, stayClasses(clDirt,1), scaleByMapSize(13, 200),10);
 
 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, avoidClasses(clWater, 3, clHill, 2, clPlayer, 5, clDirt, 1, clForest, 0, clPyrenneans,2), scaleByMapSize(13, 200) );
 createObjectGroupsDeprecated(group, 0, stayClasses(clDirt,1), scaleByMapSize(13, 200),10);
 RMS.SetProgress(75);
 
 log("Creating bushes...");
 group = new SimpleGroup( [new SimpleObject(aBushMedium, 1,2, 0,2), new SimpleObject(aBushSmall, 2,4, 0,2)] );
 createObjectGroupsDeprecated(group, 0, avoidClasses(clWater, 2, clPlayer, 1, clPyrenneans, 1), scaleByMapSize(13, 200), 50 );
 
 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);
 createObjectGroupsDeprecated(group, 0,  avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clRock, 8, clPyrenneans, 1),  scaleByMapSize(4,16), 100 );
 
 log("Creating small stone quarries...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroupsDeprecated(group, 0,  avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clRock, 8, clPyrenneans, 1),  scaleByMapSize(4,16), 100 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroupsDeprecated(group, 0, avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clMetal, 8, clRock, 5, clPyrenneans, 1), scaleByMapSize(4,16), 100  );
 
 RMS.SetProgress(85);
 
 log("Creating small decorative rocks...");
 group = new SimpleGroup( [new SimpleObject(aRockMedium, 1,3, 0,1)], true );
 createObjectGroupsDeprecated( group, 0, avoidClasses(clWater, 0, clForest, 0, clPlayer, 0), scaleByMapSize(16, 262), 50 );
 
 log("Creating large decorative rocks...");
 group = new SimpleGroup( [new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)], true );
 createObjectGroupsDeprecated( group, 0,  avoidClasses(clWater, 0, clForest, 0, clPlayer, 0), scaleByMapSize(8, 131), 50 );
 
 RMS.SetProgress(90);
 
 log("Creating deer...");
 group = new SimpleGroup( [new SimpleObject(oDeer, 5,7, 0,4)], true, clFood );
 createObjectGroupsDeprecated(group, 0,  avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clPyrenneans, 1, clFood, 15),  3 * numPlayers, 50 );
 
 log("Creating rabbit...");
 group = new SimpleGroup( [new SimpleObject(oRabbit, 2,3, 0,2)], true, clFood );
 createObjectGroupsDeprecated(group, 0, avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clPyrenneans, 1, clFood,15), 3 * numPlayers, 50 );
 
 log("Creating berry bush...");
 group = new SimpleGroup( [new SimpleObject(oBerryBush, 5,7, 0,4)],true, clFood );
 createObjectGroupsDeprecated(group, 0, avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clPyrenneans, 1, clFood, 10), randIntInclusive(1, 4) * numPlayers + 2, 50);
 
 log("Creating fish...");
 group = new SimpleGroup( [new SimpleObject(oFish, 2,3, 0,2)], true, clFood );
 createObjectGroupsDeprecated(group, 0, [avoidClasses(clFood, 15), stayClasses(clWater, 6)], 20 * numPlayers, 60 );
 
 setSunElevation(randFloat(PI/5, PI / 3));
 setSunRotation(randFloat(0, TWO_PI));
 
 setSkySet("cumulus");
 setSunColor(0.73,0.73,0.65);
 setTerrainAmbientColor(0.45,0.45,0.50);
 setUnitsAmbientColor(0.4,0.4,0.4);
 setWaterColor(0.263, 0.353, 0.616);
 setWaterTint(0.104, 0.172, 0.563);
 setWaterWaviness(5.0);
 setWaterType("ocean");
 setWaterMurkiness(0.83);
 
 ExportMap();
 
 function getNeighborsHeight(x1, z1)
 {
 	var toCheck = [ [-1,-1], [-1,0], [-1,1], [0,1], [1,1], [1,0], [1,-1], [0,-1] ];
 	var height = 0;
 	for (var i in toCheck) {
 		var xx = x1 + toCheck[i][0];
 		var zz = z1 + toCheck[i][1];
 		height += getHeight(round(xx),round(zz));
 	}
 	height /= 8;
 	return height;
 }
 // Taken from Corsica vs Sardinia with tweaks
 function PassMaker(x1, z1, x2, z2, startWidth, centerWidth, startElevation, centerElevation, smooth, tileclass, terrain)
 {
 	var mapSize = g_Map.size;
 	var stepNB = sqrt((x2-x1)*(x2-x1) + (z2-z1)*(z2-z1)) + 2;
 
 	var startHeight = startElevation;
 	var finishHeight = centerElevation;
 
 	for (var step = 0; step <= stepNB; step+=0.5)
 	{
 		var ix = ((stepNB-step)*x1 + x2*step) / stepNB;
 		var iz = ((stepNB-step)*z1 + z2*step) / stepNB;
 
 		var width = (abs(step - stepNB/2.0) *startWidth + (stepNB/2 - abs(step - stepNB/2.0)) * centerWidth ) / (stepNB/2);
 
 		var oldDirection = [x2-x1, z2-z1];
 		// let's get the perpendicular direction
 		var direction = [ -oldDirection[1],oldDirection[0] ];
 		if (abs(direction[0]) > abs(direction[1]))
 		{
 			direction[1] = direction[1] / abs(direction[0]);
 			if (direction[0] > 0)
 				direction[0] = 1;
 			else
 				direction[0] = -1;
 		} else {
 			direction[0] = direction[0] / abs(direction[1]);
 			if (direction[1] > 0)
 				direction[1] = 1;
 			else
 				direction[1] = -1;
 		}
 		for (var po = -Math.floor(width/2.0); po <= Math.floor(width/2.0); po+=0.5)
 		{
 			var rx = po*direction[0];
 			var rz = po*direction[1];
 
 			var targetHeight = (abs(step - stepNB/2.0) *startHeight + (stepNB/2 - abs(step - stepNB/2.0)) * finishHeight ) / (stepNB/2);
 			if (round(ix + rx) < mapSize && round(iz + rz) < mapSize && round(ix + rx) >= 0 && round(iz + rz) >= 0)
 			{
 				// smoothing the sides
 				if ( abs(abs(po) - abs(Math.floor(width/2.0))) < smooth)
 				{
 					var localHeight = getHeight(round(ix + rx), round(iz + rz));
 					var localPart = smooth - abs(abs(po) - abs(Math.floor(width/2.0)));
 					var targetHeight = (localHeight * localPart + targetHeight * (1/localPart) )/ (localPart + 1/localPart);
 				}
 
 				g_Map.setHeight(round(ix + rx), round(iz + rz), targetHeight);
 				if (tileclass != null)
 					addToClass(round(ix + rx), round(iz + rz), tileclass);
 				if (terrain != null)
 					placeTerrain(round(ix + rx), round(iz + rz), terrain);
 			}
 		}
 	}
 }
 // no need for preliminary rounding
 function getHeightDifference(x1, z1)
 {
 	x1 = round(x1);
 	z1 = round(z1);
 	var height = getHeight(x1,z1);
 
 	if (!g_Map.inMapBounds(x1,z1))
 		return 0;
 	// I wanna store the height difference with any neighbor
 
 	var toCheck = [ [-1,-1], [-1,0], [-1,1], [0,1], [1,1], [1,0], [1,-1], [0,-1] ];
 
 	var diff = 0;
 	var todiv = 0;
 	for (var i in toCheck) {
 		var xx = round(x1 + toCheck[i][0]);
 		var zz = round(z1 + toCheck[i][1]);
 		if (g_Map.inMapBounds(xx,zz)) {
 			diff += abs(getHeight(xx,zz) - height);
 			todiv++;
 		}
 	}
 	if (todiv > 0)
 		diff /= todiv;
 	return diff;
 }
 
Index: ps/trunk/binaries/data/mods/public/maps/random/rivers.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/rivers.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/rivers.js	(revision 20301)
@@ -1,447 +1,433 @@
 RMS.LoadLibrary("rmgen");
 RMS.LoadLibrary("rmbiome");
 
 setSelectedBiome();
 
 const tMainTerrain = g_Terrains.mainTerrain;
 const tForestFloor1 = g_Terrains.forestFloor1;
 const tForestFloor2 = g_Terrains.forestFloor2;
 const tCliff = g_Terrains.cliff;
 const tTier1Terrain = g_Terrains.tier1Terrain;
 const tTier2Terrain = g_Terrains.tier2Terrain;
 const tTier3Terrain = g_Terrains.tier3Terrain;
 const tHill = g_Terrains.hill;
 const tRoad = g_Terrains.road;
 const tRoadWild = g_Terrains.roadWild;
 const tTier4Terrain = g_Terrains.tier4Terrain;
 var tShore = g_Terrains.shore;
 var tWater = g_Terrains.water;
 if (currentBiome() == "tropic")
 {
 	tShore = "tropic_dirt_b_plants";
 	tWater = "tropic_dirt_b";
 }
 const oTree1 = g_Gaia.tree1;
 const oTree2 = g_Gaia.tree2;
 const oTree3 = g_Gaia.tree3;
 const oTree4 = g_Gaia.tree4;
 const oTree5 = g_Gaia.tree5;
 const oFruitBush = g_Gaia.fruitBush;
 const oMainHuntableAnimal = g_Gaia.mainHuntableAnimal;
 const oFish = g_Gaia.fish;
 const oSecondaryHuntableAnimal = g_Gaia.secondaryHuntableAnimal;
 const oStoneLarge = g_Gaia.stoneLarge;
 const oStoneSmall = g_Gaia.stoneSmall;
 const oMetalLarge = g_Gaia.metalLarge;
 
 const aGrass = g_Decoratives.grass;
 const aGrassShort = g_Decoratives.grassShort;
 const aReeds = g_Decoratives.reeds;
 const aLillies = g_Decoratives.lillies;
 const aRockLarge = g_Decoratives.rockLarge;
 const aRockMedium = g_Decoratives.rockMedium;
 const aBushMedium = g_Decoratives.bushMedium;
 const aBushSmall = g_Decoratives.bushSmall;
 
 const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
 const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 const mapArea = mapSize*mapSize;
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 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();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	fx = fractionToTiles(playerX[i]);
 	fz = fractionToTiles(playerZ[i]);
 	ix = round(fx);
 	iz = round(fz);
 	addCivicCenterAreaToClass(ix, iz, clPlayer);
 
 	// 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);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oFruitBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 		mAngle = randFloat(0, TWO_PI);
 
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var num = 2;
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(11, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oTree1, num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 
 RMS.SetProgress(20);
 
 //init rivers
 var PX = [];
 var PZ = [];
 
 //isRiver actually tells us if two points must be joined by river
 var isRiver = [];
 for (let m = 0; m < numPlayers + 1; ++m)
 {
 	isRiver[m] = [];
 	for (let n = 0; n < numPlayers + 1; ++n)
 		isRiver[m][n] = 0;
 }
 
 //creating the first point in the center. all others are
 //connected to this one so all of our rivers join together
 //in the middle of the map
 var fx = fractionToTiles(0.5);
 var fz = fractionToTiles(0.5);
 var ix = round(fx);
 var iz = round(fz);
 PX[numPlayers]= fx;
 PZ[numPlayers]= fz;
 
 var riverAngle = [];
 for (var c = 0 ; c < numPlayers ; c++)
 {
 	//creating other points of the river and making them
 	// join the point in the center of the map
 	riverAngle[c] = startAngle + (((2 * c + 1) / (numPlayers * 2)) * TWO_PI );
 	PX[c] = round(fractionToTiles(0.5 + 0.5 * cos(riverAngle[c])));
 	PZ[c] = round(fractionToTiles(0.5 + 0.5 * sin(riverAngle[c])));
 	//log (playerIDs[c], ",,," ,playerIDs[0]);
 	//isRiver[c][numPlayers]=1;
 	if ((c == numPlayers-1)&&(!areAllies(playerIDs[c]-1, playerIDs[0]-1)))
 		isRiver[c][numPlayers]=1;
 	else if ((c < numPlayers-1)&&(!areAllies(playerIDs[c]-1, playerIDs[c+1]-1)))
 		isRiver[c][numPlayers]=1;
 }
 
 //theta is the start value for rndRiver function. seed implies
 //the randomness. we must have one of these for each river we create.
 //shallowpoint and shallow length define the place and size of the shallow part
 var theta = [];
 var seed = [];
 var shallowpoint = [];
 var shallowlength = [];
 for (let q = 0; q < numPlayers + 1; ++q)
 {
 	theta[q]=randFloat(0, 1);
 	seed[q]=randFloat(2,3);
 	shallowpoint[q]=randFloat(0.2,0.7);
 	shallowlength[q]=randFloat(0.12,0.21);
 }
 
 log ("Creating rivers...");
 //checking all the tiles
 for (var ix = 0; ix < mapSize; ix++)
 	for (var iz = 0; iz < mapSize; iz++)
 		for (var m = 0; m < numPlayers+1; m++)
 			for (var n = 0; n < numPlayers+1; n++)
 			{
 				//checking if there is a river between those points
 				if(isRiver[m][n] == 1)
 				{
 					//very important calculations. don't change anything. results
 					//"dis" which is the distance to the riverline and "y" and "xm" which are
 					//the coordinations for the point it's image is in.
 					var a = PZ[m]-PZ[n];
 					var b = PX[n]-PX[m];
 					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);
 					//this calculates which "part" of the river are we in now.
 					//used for the function rndRiver.
 					var sit = sqrt((PZ[n]-y)*(PZ[n]-y)+(PX[n]-xm)*(PX[n]-xm))/sqrt((PZ[n]-PZ[m])*(PZ[n]-PZ[m])+(PX[n]-PX[m])*(PX[n]-PX[m]));
 					var sbms = scaleByMapSize(5,15) + alamat * ( scaleByMapSize(20, 60) * rndRiver( theta[m] + sit * 0.5 * (mapSize/64) , seed[m]) );
 					if((dis < sbms)&&(y <= Math.max(PZ[m],PZ[n]))&&(y >= Math.min(PZ[m],PZ[n])))
 					{
 						//create the deep part of the river
 						if (dis <= sbms-5){
 							if ((sit > shallowpoint[m])&&(sit < shallowpoint[m]+shallowlength[m]))
 							{
 								//create the shallow part
 								var h = -1;
 								addToClass(ix, iz, clShallow);
 							}
 							else
-							{
 								var h = -3;
-							}
+
 							var t = tWater;
 							addToClass(ix, iz, clWater);
 						}
 						//creating the rough edges
 						else if (dis <= sbms)
 						{
 							if ((sit > shallowpoint[m])&&(sit < shallowpoint[m]+shallowlength[m]))
 							{
 								if (2-(sbms-dis)<-1)
 								{
 									//checking if there is shallow water here
 									var h = -1;
 									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
 						if (getHeight(ix, iz)>h)
 						{
 							placeTerrain(ix, iz, t);
 							setHeight(ix, iz, h);
 						}
 					}
 				}
 			}
 
 RMS.SetProgress(40);
 
 createBumps(avoidClasses(clWater, 2, clPlayer, 20));
 
 if (randBool())
 	createHills([tMainTerrain, tCliff, tHill], avoidClasses(clPlayer, 20, clHill, 15, clWater, 2), clHill, scaleByMapSize(3, 15));
 else
 	createMountains(tCliff, avoidClasses(clPlayer, 20, clHill, 15, clWater, 2), clHill, scaleByMapSize(3, 15));
 
 createForests(
  [tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
  avoidClasses(clPlayer, 20, clForest, 17, clHill, 0, clWater, 2),
  clForest,
  1,
  ...rBiomeTreeCount(1));
 
 RMS.SetProgress(50);
 
 log("Creating dirt patches...");
 createLayeredPatches(
  [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
  [[tMainTerrain,tTier1Terrain],[tTier1Terrain,tTier2Terrain], [tTier2Terrain,tTier3Terrain]],
  [1,1],
  avoidClasses(clWater, 3, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12)
 );
 
 log("Creating grass patches...");
 createPatches(
  [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
  tTier4Terrain,
  avoidClasses(clWater, 3, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12)
 );
 
 RMS.SetProgress(55);
 
 log("Creating stone mines...");
 createMines(
  [
   [new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)],
   [new SimpleObject(oStoneSmall, 2,5, 1,3)]
  ],
  avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clRock, 10, clHill, 1)
 );
 
 log("Creating metal mines...");
 createMines(
  [
   [new SimpleObject(oMetalLarge, 1,1, 0,4)]
  ],
  avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 1),
  clMetal
 );
 
 RMS.SetProgress(65);
 
 var planetm = 1;
 
 if (currentBiome() == "tropic")
 	planetm = 8;
 
 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),
   planetm * scaleByMapSize(13, 200),
   planetm * scaleByMapSize(13, 200),
   planetm * scaleByMapSize(13, 200)
  ],
  avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0)
 );
 
 // create water decoration in the shallow parts
 createDecoration
 (
  [[new SimpleObject(aReeds, 1,3, 0,1)],
   [new SimpleObject(aLillies, 1,2, 0,1)]
  ],
  [
   scaleByMapSize(800, 12800),
   scaleByMapSize(800, 12800)
  ],
  stayClasses(clShallow, 0)
 );
 
 RMS.SetProgress(70);
 
 createFood
 (
  [
   [new SimpleObject(oMainHuntableAnimal, 5,7, 0,4)],
   [new SimpleObject(oSecondaryHuntableAnimal, 2,3, 0,2)]
  ],
  [
   3 * numPlayers,
   3 * numPlayers
  ],
  avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 20)
 );
 
 createFood
 (
  [
   [new SimpleObject(oFruitBush, 5,7, 0,4)]
  ],
  [
   3 * numPlayers
  ],
  avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 10)
 );
 
 createFood
 (
  [
   [new SimpleObject(oFish, 2,3, 0,2)]
  ],
  [
   25 * numPlayers
  ],
  [avoidClasses(clFood, 20), stayClasses(clWater, 6)]
 );
 
 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");
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/saharan_oases.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/saharan_oases.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/saharan_oases.js	(revision 20301)
@@ -1,287 +1,289 @@
 RMS.LoadLibrary("rmgen");
 
 const tCity = "desert_city_tile";
 const tCityPlaza = "desert_city_tile_plaza";
 const tFineSand = "desert_sand_smooth";
 const tDirt1 = "desert_dirt_rough_2";
 const tSandDunes = "desert_sand_dunes_50";
 const tDirt2 = "desert_dirt_rough";
 const tDirtCracks = "desert_dirt_cracks";
 const tShore = "desert_shore_stones";
 const tWaterDeep = "desert_shore_stones_wet";
 const tLush = "desert_grass_a";
 const tSLush = "desert_grass_a_sand";
 
 const oGrapeBush = "gaia/flora_bush_grapes";
 const oCamel = "gaia/fauna_camel";
 const oGazelle = "gaia/fauna_gazelle";
 const oGoat = "gaia/fauna_goat";
 const oStoneLarge = "gaia/geology_stonemine_desert_badlands_quarry";
 const oStoneSmall = "gaia/geology_stone_desert_small";
 const oMetalLarge = "gaia/geology_metal_desert_slabs";
 const oDatePalm = "gaia/flora_tree_date_palm";
 const oSDatePalm = "gaia/flora_tree_cretan_date_palm_short";
 const oWood = "gaia/special_treasure_wood";
 const oFood = "gaia/special_treasure_food_bin";
 
 const aBush1 = "actor|props/flora/bush_desert_a.xml";
 const aBush2 = "actor|props/flora/bush_desert_dry_a.xml";
 const aBush3 = "actor|props/flora/bush_medit_sm_dry.xml";
 const aBush4 = "actor|props/flora/plant_desert_a.xml";
 const aDecorativeRock = "actor|geology/stone_desert_med.xml";
 
 // terrain + entity (for painting)
 const pForest = [tLush + TERRAIN_SEPARATOR + oDatePalm, tLush + TERRAIN_SEPARATOR + oSDatePalm, tLush];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 
 var clPlayer = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clGrass = createTileClass();
 var clPond = createTileClass();
 var clTreasure = createTileClass();
 
 var [playerIDs, playerX, playerZ, playerAngle] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = floor(fx);
 	var iz = floor(fz);
 	addToClass(ix, iz, clPlayer);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	var placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tCityPlaza, tCity], [1]);
 	createArea(placer, painter, null);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oGrapeBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = radius - 5;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 	var hillSize = PI * radius * radius;
 	// create starting trees
 	var num = floor(hillSize / 100);
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = 12;
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oSDatePalm, num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aBush1, clBaseResource, radius);
 }
 
 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
 );
 
 log("Creating small stone quarries...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 1, clPlayer, 26, clRock, 10, clWater, 1),
 	2*scaleByMapSize(4,16), 100
 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 1, clPlayer, 26, clMetal, 10, clRock, 5, clWater, 1),
 	2*scaleByMapSize(4,16), 100
 );
 
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aDecorativeRock, 1,3, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clWater, 1, clForest, 0, clPlayer, 0, clPond, 1),
 	scaleByMapSize(16, 262), 50
 );
 
 log("Creating shrubs...");
 group = new SimpleGroup(
 	[new SimpleObject(aBush2, 1,2, 0,1), new SimpleObject(aBush1, 1,3, 0,2), new SimpleObject(aBush4, 1,2, 0,1), new SimpleObject(aBush3, 1,3, 0,2)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clWater, 1, clPlayer, 0, clPond, 1),
 	scaleByMapSize(10, 100), 50
 );
 
 log("Creating small decorative rocks on mines...");
 group = new SimpleGroup(
 	[new SimpleObject(aDecorativeRock, 1,3, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	stayClasses(clRock, 0),
 	5*scaleByMapSize(16, 262), 50
 );
 
 group = new SimpleGroup(
 	[new SimpleObject(aDecorativeRock, 1,3, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	stayClasses(clMetal, 0),
 	5*scaleByMapSize(16, 262), 50
 );
 
 log("Creating gazelles...");
 group = new SimpleGroup([new SimpleObject(oGazelle, 5,7, 0,4)], true, clFood);
 createObjectGroupsDeprecated(group, 0,
 	borderClasses(clWater, 8, 5),
 	6*scaleByMapSize(5,20), 50
 );
 
 log("Creating goats...");
 group = new SimpleGroup([new SimpleObject(oGoat, 2,4, 0,3)], true, clFood);
 createObjectGroupsDeprecated(group, 0,
 	borderClasses(clWater, 8, 5),
 	5*scaleByMapSize(5,20), 50
 );
 
 log("Creating treasures...");
 group = new SimpleGroup([new SimpleObject(oFood, 1,1, 0,2)], true, clTreasure);
 createObjectGroupsDeprecated(group, 0,
 	borderClasses(clWater, 8, 5),
 	3*scaleByMapSize(5,20), 50
 );
 
 group = new SimpleGroup([new SimpleObject(oWood, 1,1, 0,2)], true, clTreasure);
 createObjectGroupsDeprecated(group, 0,
 	borderClasses(clWater, 8, 5),
 	3*scaleByMapSize(5,20), 50
 );
 
 log("Creating camels...");
 group = new SimpleGroup([new SimpleObject(oCamel, 2,4, 0,2)], true, clFood);
 createObjectGroupsDeprecated(group, 0,
 	borderClasses(clWater, 14, 5),
 	5*scaleByMapSize(5,20), 50
 );
 
 setSkySet("sunny");
 setSunColor(0.746, 0.718, 0.539);
 setWaterColor(0, 0.227, 0.843);
 setWaterTint(0, 0.545, 0.859);
 setWaterWaviness(1.0);
 setWaterType("clap");
 setWaterMurkiness(0.5);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/sahel_watering_holes.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/sahel_watering_holes.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/sahel_watering_holes.js	(revision 20301)
@@ -1,478 +1,477 @@
 RMS.LoadLibrary("rmgen");
 
 const tGrass = "savanna_grass_a";
 const tForestFloor = "savanna_forestfloor_a";
 const tCliff = "savanna_cliff_b";
 const tDirtRocksA = "savanna_dirt_rocks_c";
 const tDirtRocksB = "savanna_dirt_rocks_a";
 const tDirtRocksC = "savanna_dirt_rocks_b";
 const tHill = "savanna_cliff_a";
 const tRoad = "savanna_tile_a_red";
 const tRoadWild = "savanna_tile_a_red";
 const tGrassPatch = "savanna_grass_b";
 const tShore = "savanna_riparian_bank";
 const tWater = "savanna_riparian_wet";
 
 const oBaobab = "gaia/flora_tree_baobab";
 const oFig = "gaia/flora_tree_fig";
 const oBerryBush = "gaia/flora_bush_berry";
 const oWildebeest = "gaia/fauna_wildebeest";
 const oFish = "gaia/fauna_fish";
 const oGazelle = "gaia/fauna_gazelle";
 const oElephant = "gaia/fauna_elephant_african_bush";
 const oGiraffe = "gaia/fauna_giraffe";
 const oZebra = "gaia/fauna_zebra";
 const oStoneLarge = "gaia/geology_stonemine_desert_quarry";
 const oStoneSmall = "gaia/geology_stone_savanna_small";
 const oMetalLarge = "gaia/geology_metal_savanna_slabs";
 
 const aGrass = "actor|props/flora/grass_savanna.xml";
 const aGrassShort = "actor|props/flora/grass_medit_field.xml";
 const aRockLarge = "actor|geology/stone_savanna_med.xml";
 const aRockMedium = "actor|geology/stone_savanna_med.xml";
 const aBushMedium = "actor|props/flora/bush_desert_dry_a.xml";
 const aBushSmall = "actor|props/flora/bush_dry_a.xml";
 
 const pForest = [tForestFloor + TERRAIN_SEPARATOR + oBaobab, tForestFloor + TERRAIN_SEPARATOR + oBaobab, tForestFloor];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clShallows = createTileClass();
 
 var [playerIDs, playerX, playerZ, playerAngle, startAngle] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 	addCivicCenterAreaToClass(ix, iz, clPlayer);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	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);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oBerryBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var num = 5;
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(12, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oBaobab, num, num, 0,3)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 
 RMS.SetProgress(20);
 
 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++)
 {
 	if (i+1 == numPlayers)
 	{
 		passageMaker(
 			round(fractionToTiles(playerX[i])),
 			round(fractionToTiles(playerZ[i])),
 			round(fractionToTiles(playerX[0])),
 			round(fractionToTiles(playerZ[0])),
 			6, -2, -2, 4, clShallows, undefined, -4);
 
 		log("Creating animals in shallows...");
 		var group = new SimpleGroup(
 			[new SimpleObject(oElephant, 2,3, 0,4)],
 			true, clFood, round((fractionToTiles(playerX[i]) + fractionToTiles(playerX[0]))/2), round((fractionToTiles(playerZ[i]) + fractionToTiles(playerZ[0]))/2)
 		);
 		createObjectGroup(group, 0);
 
 		var group = new SimpleGroup(
 			[new SimpleObject(oWildebeest, 5,6, 0,4)],
 			true, clFood, round((fractionToTiles(playerX[i]) + fractionToTiles(playerX[0]))/2), round((fractionToTiles(playerZ[i]) + fractionToTiles(playerZ[0]))/2)
 		);
 		createObjectGroup(group, 0);
-
 	}
 	else
 	{
 		passageMaker(
 			fractionToTiles(playerX[i]),
 			fractionToTiles(playerZ[i]),
 			fractionToTiles(playerX[i+1]),
 			fractionToTiles(playerZ[i+1]),
 			6, -2, -2, 4, clShallows, undefined, -4);
 
 		log("Creating animals in shallows...");
 		var group = new SimpleGroup(
 			[new SimpleObject(oElephant, 2,3, 0,4)],
 			true, clFood, round((fractionToTiles(playerX[i]) + fractionToTiles(playerX[i+1]))/2), round((fractionToTiles(playerZ[i]) + fractionToTiles(playerZ[i+1]))/2)
 		);
 		createObjectGroup(group, 0);
 
 		var group = new SimpleGroup(
 			[new SimpleObject(oWildebeest, 5,6, 0,4)],
 			true, clFood, round((fractionToTiles(playerX[i]) + fractionToTiles(playerX[i+1]))/2), round((fractionToTiles(playerZ[i]) + fractionToTiles(playerZ[i+1]))/2)
 		);
 		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;
 var MAX_TREES = 900;
 var P_FOREST = 0.02;
 
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 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 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
 );
 
 log("Creating small stone quarries...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clRock, 10, clHill, 1),
 	scaleByMapSize(4,16), 100
 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 1),
 	scaleByMapSize(4,16), 100
 );
 
 RMS.SetProgress(65);
 
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockMedium, 1,3, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0),
 	scaleByMapSize(16, 262), 50
 );
 
 log("Creating large decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0),
 	scaleByMapSize(8, 131), 50
 );
 
 RMS.SetProgress(70);
 
 log("Creating wildebeest...");
 group = new SimpleGroup(
 	[new SimpleObject(oWildebeest, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 5),
 	3 * numPlayers, 50
 );
 
 RMS.SetProgress(75);
 
 log("Creating gazelle...");
 group = new SimpleGroup(
 	[new SimpleObject(oGazelle, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 5),
 	3 * numPlayers, 50
 );
 
 log("Creating elephant...");
 group = new SimpleGroup(
 	[new SimpleObject(oElephant, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 5),
 	3 * numPlayers, 50
 );
 
 log("Creating giraffe...");
 group = new SimpleGroup(
 	[new SimpleObject(oGiraffe, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 5),
 	3 * numPlayers, 50
 );
 
 log("Creating zebra...");
 group = new SimpleGroup(
 	[new SimpleObject(oZebra, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 5),
 	3 * numPlayers, 50
 );
 
 log("Creating fish...");
 group = new SimpleGroup(
 	[new SimpleObject(oFish, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clFood, 20), stayClasses(clWater, 6)],
 	25 * numPlayers, 60
 );
 
 log("Creating berry bush...");
 group = new SimpleGroup(
 	[new SimpleObject(oBerryBush, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 10),
 	randIntInclusive(1, 4) * numPlayers + 2, 50
 );
 
 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...");
 group = new SimpleGroup(
 	[new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)]
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 2, clHill, 2, clPlayer, 2),
 	planetm * 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,
 	avoidClasses(clWater, 3, clHill, 2, clPlayer, 2, clForest, 0),
 	planetm * 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,
 	avoidClasses(clWater, 2, clHill, 1, clPlayer, 1),
 	planetm * scaleByMapSize(13, 200), 50
 );
 
 setSkySet("sunny");
 
 setSunRotation(randFloat(0, TWO_PI));
 setSunElevation(randFloat(PI/ 5, PI / 4));
 setWaterColor(0.478,0.42,0.384);				// greyish
 setWaterTint(0.58,0.22,0.067);				// reddish
 setWaterMurkiness(0.87);
 setWaterWaviness(0.5);
 setWaterType("clap");
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/syria.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/syria.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/syria.js	(revision 20301)
@@ -1,355 +1,320 @@
 RMS.LoadLibrary("rmgen");
 
 //terrain textures
 const tMainDirt = ["desert_dirt_rocks_1", "desert_dirt_cracks"];
 const tForestFloor1 = "forestfloor_dirty";
 const tForestFloor2 = "desert_forestfloor_palms";
 const tGrassSands = "desert_grass_a_sand";
 const tGrass = "desert_grass_a";
 const tSecondaryDirt = "medit_dirt_dry";
 const tCliff = ["desert_cliff_persia_1", "desert_cliff_persia_2"];
 const tHill = ["desert_dirt_rocks_1", "desert_dirt_rocks_2", "desert_dirt_rocks_3"];
 const tDirt = ["desert_dirt_rough", "desert_dirt_rough_2"];
 const tRoad = "desert_shore_stones";;
 const tRoadWild = "desert_grass_a_stones";;
 
 const oTamarix = "gaia/flora_tree_tamarix";
 const oPalm = "gaia/flora_tree_date_palm";
 const oPine = "gaia/flora_tree_aleppo_pine";
 const oBush = "gaia/flora_bush_grapes";
 const oCamel = "gaia/fauna_camel";
 const oGazelle = "gaia/fauna_gazelle";
 const oLion = "gaia/fauna_lion";
 const oStoneLarge = "gaia/geology_stonemine_desert_quarry";
 const oStoneSmall = "gaia/geology_stone_desert_small";
 const oMetalLarge = "gaia/geology_metal_desert_slabs";
 
 const aRock = "actor|geology/stone_desert_med.xml";
 const aBushA = "actor|props/flora/bush_desert_dry_a.xml";
 const aBushB = "actor|props/flora/bush_desert_dry_a.xml";
 const aBushes = [aBushA, aBushB];
 
 const pForestP = [tForestFloor2 + TERRAIN_SEPARATOR + oPalm, tForestFloor2];
 const pForestT = [tForestFloor1 + TERRAIN_SEPARATOR + oTamarix,tForestFloor2];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clGrass = createTileClass();
 
 var [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	// scale radius of player area by map size
 	var radius = scaleByMapSize(15,25);
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 
 	// calculate size based on the radius
 	var size = PI * radius * radius;
 
 	// create the player area
 	var placer = new ClumpPlacer(size, 0.9, 0.5, 10, ix, iz);
 	createArea(placer, paintClass(clPlayer), null);
 
 	// create the grass patches
 	var grassRadius = floor(scaleByMapSize(16 ,30));
 	placer = new ChainPlacer(2, floor(scaleByMapSize(5, 12)), floor(scaleByMapSize(25, 60)), 1, ix, iz, 0, [grassRadius]);
 	var painter = new LayeredPainter([tGrassSands, tGrass], [3]);
 	createArea(placer, [painter, paintClass(clGrass)], null);
 
 	// create the city patch
 	var cityRadius = 10;
 	placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tRoadWild, tRoad], [3]);
 	createArea(placer, painter, null);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = 11;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0), new RandomObject(aBushes, 2,4, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2), new RandomObject(aBushes, 2,4, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var num = 3;
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(11, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(pickRandom([oPalm, oTamarix]), num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 }
 
 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);
 
 // calculate desired number of trees for map (based on size)
 const MIN_TREES = 400;
 const MAX_TREES = 2000;
 const P_FOREST = 0.7;
 
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 var numForest = totalTrees * P_FOREST;
 var numStragglers = totalTrees * (1.0 - P_FOREST);
 
 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
 );
 
 log("Creating small stone quarries...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3), 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
 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4), new RandomObject(aBushes, 2,4, 0,2)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 10, clMetal, 10, clRock, 5, clHill, 1, clGrass, 1)],
 	scaleByMapSize(2,8), 100
 );
 
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRock, 1,3, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clForest, 0, clPlayer, 0, clHill, 0),
 	scaleByMapSize(16, 262), 50
 );
 
 log("Creating bushes...");
 group = new SimpleGroup(
 	[new SimpleObject(aBushB, 1,2, 0,1), new SimpleObject(aBushA, 1,3, 0,2)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clForest, 0, clPlayer, 0, clHill, 0),
 	scaleByMapSize(50, 500), 50
 );
 RMS.SetProgress(80);
 
 log("Creating gazelle...");
 group = new SimpleGroup(
 	[new SimpleObject(oGazelle, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 1, clHill, 1, clFood, 20, clGrass, 2),
 	3 * numPlayers, 50
 );
 
 log("Creating lions...");
 group = new SimpleGroup(
 	[new SimpleObject(oLion, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 1, clHill, 1, clFood, 20, clGrass, 2),
 	3 * numPlayers, 50
 );
 
 log("Creating camels...");
 group = new SimpleGroup(
 	[new SimpleObject(oCamel, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 1, clHill, 1, clFood, 20, clGrass, 2),
 	3 * numPlayers, 50
 );
 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);
 setSunRotation(randFloat(0, TWO_PI));
 setSunColor(0.746, 0.718, 0.539);
 setWaterColor(0.292, 0.347, 0.691);
 setWaterTint(0.550, 0.543, 0.437);
 setWaterMurkiness(0.83);
 
 setFogColor(0.8, 0.76, 0.61);
 setFogThickness(0.2);
 setFogFactor(0.4);
 
 setPPEffect("hdr");
 setPPContrast(0.65);
 setPPSaturation(0.42);
 setPPBloom(0.6);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/sahel.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/sahel.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/sahel.js	(revision 20301)
@@ -1,305 +1,287 @@
 RMS.LoadLibrary("rmgen");
 
 const tGrass2 = "savanna_grass_b";
 const tGrass3 = "savanna_shrubs_a";
 const tDirt1 = "savanna_dirt_rocks_a";
 const tDirt2 = "savanna_dirt_rocks_b";
 const tDirt3 = "savanna_dirt_rocks_c";
 const tDirt4 = "savanna_dirt_b";
 const tCityTiles = "savanna_tile_a";
 const tShore = "savanna_riparian_bank";
 const tWater = "savanna_riparian_wet";
 
 const oBaobab = "gaia/flora_tree_baobab";
 const oBerryBush = "gaia/flora_bush_berry";
 const oGazelle = "gaia/fauna_gazelle";
 const oGiraffe = "gaia/fauna_giraffe";
 const oGiraffeInfant = "gaia/fauna_giraffe_infant";
 const oElephant = "gaia/fauna_elephant_african_bush";
 const oElephantInfant = "gaia/fauna_elephant_african_infant";
 const oLion = "gaia/fauna_lion";
 const oLioness = "gaia/fauna_lioness";
 const oZebra = "gaia/fauna_zebra";
 const oStoneSmall = "gaia/geology_stone_savanna_small";
 const oMetalLarge = "gaia/geology_metal_savanna_slabs";
 
 const aBush = "actor|props/flora/bush_medit_sm_dry.xml";
 const aRock = "actor|geology/stone_savanna_med.xml";
 
 InitMap();
 
 var numPlayers = getNumPlayers();
 var mapSize = getMapSize();
 
 var clPlayer = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 
 var [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 	addCivicCenterAreaToClass(ix, iz, clPlayer);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oBerryBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = 13;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	createStoneMineFormation(mX, mZ, tDirt4);
 	addToClass(mX, mZ, clPlayer);
 	// create the city patch
 	var cityRadius = radius/3;
 	var placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new TerrainPainter(tCityTiles);
 	createArea(placer, painter, null);
 
 	var hillSize = PI * radius * radius;
 	// create starting trees
 	var num = floor(hillSize / 300);
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(11, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oBaobab, num, num, 2,7)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 }
 
 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);
 var minesConstraint = new AvoidTileClassConstraint(clRock, 25);
 var waterConstraint = new AvoidTileClassConstraint(clWater, 10);
 
 log("Creating stone mines...");
 for (var i = 0; i < scaleByMapSize(12,30); ++i)
 {
 	var mX = randIntExclusive(0, mapSize);
 	var mZ = randIntExclusive(0, mapSize);
 	if (playerConstraint.allows(mX, mZ) && minesConstraint.allows(mX, mZ) && waterConstraint.allows(mX, mZ))
 	{
 		createStoneMineFormation(mX, mZ, tDirt4);
 		addToClass(mX, mZ, clRock);
 	}
 }
 
 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
 );
 
 RMS.SetProgress(65);
 
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRock, 1,3, 0,3)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clPlayer, 7, clWater, 1),
 	scaleByMapSize(200, 1200), 1
 );
 
 RMS.SetProgress(70);
 
 log("Creating gazelle...");
 group = new SimpleGroup(
 	[new SimpleObject(oGazelle, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 1, clPlayer, 20, clFood, 11),
 	scaleByMapSize(4,12), 50
 );
 
 log("Creating zebra...");
 group = new SimpleGroup(
 	[new SimpleObject(oZebra, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 1, clPlayer, 20, clFood, 11),
 	scaleByMapSize(4,12), 50
 );
 
 log("Creating giraffe...");
 group = new SimpleGroup(
 	[new SimpleObject(oGiraffe, 2,4, 0,4), new SimpleObject(oGiraffeInfant, 0,2, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 1, clPlayer, 20, clFood, 11),
 	scaleByMapSize(4,12), 50
 );
 
 log("Creating elephants...");
 group = new SimpleGroup(
 	[new SimpleObject(oElephant, 2,4, 0,4), new SimpleObject(oElephantInfant, 0,2, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 1, clPlayer, 20, clFood, 11),
 	scaleByMapSize(4,12), 50
 );
 
 log("Creating lions...");
 group = new SimpleGroup(
 	[new SimpleObject(oLion, 0,1, 0,4), new SimpleObject(oLioness, 2,3, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 1, clPlayer, 20, clFood, 11),
 	scaleByMapSize(4,12), 50
 );
 
 log("Creating berry bush...");
 group = new SimpleGroup(
 	[new SimpleObject(oBerryBush, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clPlayer, 20, clFood, 12, clRock, 7, clMetal, 6),
 	randIntInclusive(1, 4) * numPlayers + 2, 50
 );
 
 RMS.SetProgress(85);
 
 log("Creating straggler trees...");
 var num = scaleByMapSize(70, 500);
 group = new SimpleGroup(
 	[new SimpleObject(oBaobab, 1,1, 0,3)],
 	true, clForest
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 1, clPlayer, 20, clMetal, 6, clRock, 7, clWater, 1),
 	num
 );
 
 log("Creating large grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aBush, 2,4, 0,1.8, -PI/8,PI/8)]
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clPlayer, 2, clForest, 0),
 	scaleByMapSize(100, 1200)
 );
 
 setSunColor(0.87451, 0.847059, 0.647059);
 setWaterColor(0.741176, 0.592157, 0.27451);
 setWaterTint(0.741176, 0.592157, 0.27451);
 setWaterWaviness(2.0);
 setWaterType("clap");
 setWaterMurkiness(0.835938);
 
 setUnitsAmbientColor(0.57, 0.58, 0.55);
 setTerrainAmbientColor(0.447059, 0.509804, 0.54902);
 
 setFogFactor(0.25);
 setFogThickness(0.15);
 setFogColor(0.847059, 0.737255, 0.482353);
 
 setPPEffect("hdr");
 setPPContrast(0.57031);
 setPPBloom(0.34);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/survivalofthefittest.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/survivalofthefittest.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/survivalofthefittest.js	(revision 20301)
@@ -1,238 +1,243 @@
 RMS.LoadLibrary("rmgen");
 RMS.LoadLibrary("rmbiome");
 
 setSelectedBiome();
 
 const tMainTerrain = g_Terrains.mainTerrain;
 const tForestFloor1 = g_Terrains.forestFloor1;
 const tForestFloor2 = g_Terrains.forestFloor2;
 const tCliff = g_Terrains.cliff;
 const tHill = g_Terrains.hill;
 const tTier1Terrain = g_Terrains.tier1Terrain;
 const tTier2Terrain = g_Terrains.tier2Terrain;
 const tTier3Terrain = g_Terrains.tier3Terrain;
 const tTier4Terrain = g_Terrains.tier4Terrain;
 
 const oTree1 = g_Gaia.tree1;
 const oTree2 = g_Gaia.tree2;
 const oTree3 = g_Gaia.tree3;
 const oTree4 = g_Gaia.tree4;
 const oTree5 = g_Gaia.tree5;
 
 const aGrass = g_Decoratives.grass;
 const aGrassShort = g_Decoratives.grassShort;
 const aRockLarge = g_Decoratives.rockLarge;
 const aRockMedium = g_Decoratives.rockMedium;
 const aBushMedium = g_Decoratives.bushMedium;
 const aBushSmall = g_Decoratives.bushSmall;
 const aWaypointFlag = "actor|props/special/common/waypoint_flag.xml";
 
 const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
 const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
 
 const oTreasureSeeker = "skirmish/units/default_support_female_citizen";
 const oCivicCenter = "skirmish/structures/default_civil_centre";
 const oCitizenInfantry = "skirmish/units/default_infantry_melee_b";
 
 const triggerPointAttacker = "trigger/trigger_point_A";
 const triggerPointTreasures = [
 	"trigger/trigger_point_B",
 	"trigger/trigger_point_C",
 	"trigger/trigger_point_D"
 ];
 
 InitMap();
 
 var numPlayers = getNumPlayers();
 var mapSize = getMapSize();
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clDirt = createTileClass();
 var clBaseResource = createTileClass();
 var clLand = createTileClass();
 var clWomen = createTileClass();
 
 initTerrain(tMainTerrain);
 
 var ix = Math.round(fractionToTiles(0.5));
 var iz = Math.round(fractionToTiles(0.5));
 
 // Create the main treasure area in the middle of the map
 createArea(
 	new ClumpPlacer(mapSize * mapSize * scaleByMapSize(0.065, 0.09), 0.7, 0.1, 10, ix, iz),
 	[
 		new LayeredPainter([tMainTerrain, tMainTerrain], [3]),
 		new SmoothElevationPainter(ELEVATION_SET, 3, 3),
 		paintClass(clLand)
 	],
 	null);
+RMS.SetProgress(10);
 
 var [playerIDs, playerX, playerZ, playerAngle, startAngle] = radialPlayerPlacement(0.3);
 
 var attackerX = [];
 var attackerZ = [];
 
 for (let  i = 0; i < numPlayers; ++i)
 {
 	attackerX[i] = 0.5 + 0.45*cos(playerAngle[i]);
 	attackerZ[i] = 0.5 + 0.45*sin(playerAngle[i]);
 }
 
 for (let i = 0; i < numPlayers; ++i)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15, 25);
 
 	// place the attacker spawning trigger point
 	var ax = round(fractionToTiles(attackerX[i]));
 	var az = round(fractionToTiles(attackerZ[i]));
 	placeObject(ax, az, triggerPointAttacker, id, PI);
 	placeObject(ax, az, aWaypointFlag, 0, PI/2);
 	addToClass(ax, az, clPlayer);
 	addToClass(round(fractionToTiles((attackerX[i] + playerX[i]) / 2)), round(fractionToTiles((attackerZ[i] + playerZ[i]) / 2)), clPlayer);
 
 	// get the x and z in tiles
 	let fx = fractionToTiles(playerX[i]);
 	let fz = fractionToTiles(playerZ[i]);
 	let ix = round(fx);
 	let iz = round(fz);
 
 	addCivicCenterAreaToClass(ix, iz, clPlayer);
 
 	// Place default civ starting entities
 	var uDist = 6;
 	var uSpace = 2;
 	placeObject(fx, fz, oCivicCenter, id, BUILDING_ORIENTATION);
 	var uAngle = BUILDING_ORIENTATION - PI / 2;
 	var count = 4;
 	for (let numberofentities = 0; numberofentities < count; ++numberofentities)
 	{
 		var ux = fx + uDist * cos(uAngle) + numberofentities * uSpace * cos(uAngle + PI/2) - (0.75 * uSpace * floor(count / 2) * cos(uAngle + PI/2));
 		var uz = fz + uDist * sin(uAngle) + numberofentities * uSpace * sin(uAngle + PI/2) - (0.75 * uSpace * floor(count / 2) * sin(uAngle + PI/2));
 		placeObject(ux, uz, oCitizenInfantry, id, uAngle);
 	}
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 
 	var tang = startAngle + (i + 0.5) * 2 * PI / numPlayers;
 
 	var placer = new PathPlacer(
 		fractionToTiles(0.5),
 		fractionToTiles(0.5),
 		fractionToTiles(0.5 + 0.5 * Math.cos(tang)),
 		fractionToTiles(0.5 + 0.5 * Math.sin(tang)),
 		scaleByMapSize(14, 24),
 		0.4,
 		3 * scaleByMapSize(1, 3),
 		0.2,
 		0.05);
 
 	createArea(
 		placer,
 		[
 			new LayeredPainter([tMainTerrain, tMainTerrain], [1]),
 			new SmoothElevationPainter(ELEVATION_SET, 3, 4)
 		],
 		null);
 
 	var femaleLocation = getTIPIADBON([ix, iz], [mapSize / 2, mapSize / 2], [-3 , 3.5], 1, 3);
 	if (femaleLocation !== undefined)
 	{
 		placeObject(femaleLocation[0], femaleLocation[1], oTreasureSeeker, id, playerAngle[i] + PI);
 		addToClass(floor(femaleLocation[0]), floor(femaleLocation[1]), clWomen);
 	}
 }
+RMS.SetProgress(20);
 
 paintTerrainBasedOnHeight(3.12, 29, 1, tCliff);
 paintTileClassBasedOnHeight(3.12, 29, 1, clHill);
 
 for (let triggerPointTreasure of triggerPointTreasures)
 	createObjectGroupsDeprecated(
 		new SimpleGroup([new SimpleObject(triggerPointTreasure, 1, 1, 0, 0)], true, clWomen),
 		0,
 		[avoidClasses(clForest, 5, clPlayer, 5, clHill, 5), stayClasses(clLand, 5)],
 		scaleByMapSize(40, 140), 100
 	);
+RMS.SetProgress(25);
 
 createBumps(stayClasses(clLand, 5));
 
 createForests(
 	[tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
 	[avoidClasses(clPlayer, 20, clForest, 5, clHill, 0, clBaseResource,2, clWomen, 5), stayClasses(clLand, 4)],
 	clForest,
 	1,
 	...rBiomeTreeCount(1));
+RMS.SetProgress(30);
 
 if (randBool())
 	createHills(
 		[tMainTerrain, tCliff, tHill],
 		[avoidClasses(clPlayer, 20, clHill, 5, clBaseResource, 3, clWomen, 5), stayClasses(clLand, 5)],
 		clHill,
 		scaleByMapSize(10, 60) * numPlayers);
 else
 	createMountains(
 		tCliff,
 		[avoidClasses(clPlayer, 20, clHill, 5, clBaseResource, 3, clWomen, 5), stayClasses(clLand, 5)],
 		clHill,
 		scaleByMapSize(10, 60) * numPlayers);
+RMS.SetProgress(40);
 
 createHills(
 	[tCliff, tCliff, tHill],
 	avoidClasses(clPlayer, 20, clHill, 5, clBaseResource, 3, clWomen, 5, clLand, 5),
 	clHill,
 	scaleByMapSize(15, 90) * numPlayers,
 	undefined,
 	undefined,
 	undefined,
 	undefined,
 	55);
 
 RMS.SetProgress(50);
 
 log("Creating dirt patches...");
 createLayeredPatches(
 	[scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
 	[[tMainTerrain, tTier1Terrain], [tTier1Terrain, tTier2Terrain], [tTier2Terrain, tTier3Terrain]],
 	[1, 1],
 	[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12, clWomen, 5), stayClasses(clLand, 5)]
 );
 
 log("Creating grass patches...");
 createPatches(
 	[scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
 	tTier4Terrain,
 	[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12, clWomen, 5), stayClasses(clLand, 5)]
 );
 
 var planetm = 1;
 if (currentBiome() == "tropic")
 	planetm = 8;
 
 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),
 		planetm * scaleByMapSize(13, 200),
 		planetm * scaleByMapSize(13, 200),
 		planetm * scaleByMapSize(13, 200)
 	],
 	[avoidClasses(clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 5)]
 );
 
 log("Creating straggler trees...");
 createStragglerTrees(
 	[oTree1, oTree2, oTree4, oTree3],
 	[avoidClasses(clForest, 7, clHill, 1, clPlayer, 9), stayClasses(clLand, 7)]);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/snowflake_searocks.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/snowflake_searocks.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/snowflake_searocks.js	(revision 20301)
@@ -1,1801 +1,1775 @@
 RMS.LoadLibrary("rmgen");
 RMS.LoadLibrary("rmbiome");
 
 setSelectedBiome();
 
 const tMainTerrain = g_Terrains.mainTerrain;
 const tForestFloor1 = g_Terrains.forestFloor1;
 const tForestFloor2 = g_Terrains.forestFloor2;
 const tCliff = g_Terrains.cliff;
 const tTier1Terrain = g_Terrains.tier1Terrain;
 const tTier2Terrain = g_Terrains.tier2Terrain;
 const tTier3Terrain = g_Terrains.tier3Terrain;
 const tHill = g_Terrains.mainTerrain;
 const tRoad = g_Terrains.road;
 const tRoadWild = g_Terrains.roadWild;
 const tTier4Terrain = g_Terrains.tier4Terrain;
 const tWater = g_Terrains.water;
 
 const oTree1 = g_Gaia.tree1;
 const oTree2 = g_Gaia.tree2;
 const oTree3 = g_Gaia.tree3;
 const oTree4 = g_Gaia.tree4;
 const oTree5 = g_Gaia.tree5;
 const oFruitBush = g_Gaia.fruitBush;
 const oMainHuntableAnimal = g_Gaia.mainHuntableAnimal;
 const oSecondaryHuntableAnimal = g_Gaia.secondaryHuntableAnimal;
 const oStoneLarge = g_Gaia.stoneLarge;
 const oStoneSmall = g_Gaia.stoneSmall;
 const oMetalLarge = g_Gaia.metalLarge;
 
 const aGrass = g_Decoratives.grass;
 const aGrassShort = g_Decoratives.grassShort;
 const aRockLarge = g_Decoratives.rockLarge;
 const aRockMedium = g_Decoratives.rockMedium;
 const aBushMedium = g_Decoratives.bushMedium;
 const aBushSmall = g_Decoratives.bushSmall;
 
 const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
 const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 const mapArea = mapSize*mapSize;
 
 log(mapSize);
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clSettlement = createTileClass();
 var clLand = createTileClass();
 
 initTerrain(tWater);
 
 const radius = scaleByMapSize(15,30);
 const cliffRadius = 2;
 const elevation = 20;
 
 var [playerIDs, playerX, playerZ, playerAngle, startAngle] = radialPlayerPlacement();
 
 // Creating other islands
 var numIslands = 0;
 //****************************
 //----------------------------
 //Tiny and Small Size
 //----------------------------
 //****************************
 if ((mapSize == 128)||(mapSize == 192)){
 		//2 PLAYERS
 		//-----------------
 		//-----------------
 	if (numPlayers == 2){
 		numIslands = 4*numPlayers+1;
 		var IslandX = new Array(numIslands);
 		var IslandZ = new Array(numIslands);
 		var isConnected = new Array(numIslands);
 		for (var q=0; q <numIslands; q++)
 		{
 			isConnected[q]=new Array(numIslands);
 		}
 		for (var m = 0; m < numIslands; m++){
 			for (var n = 0; n < numIslands; n++){
 				isConnected[m][n] = 0;
 			}
 		}
 		//connections
 		var sX = 0;
 		var sZ = 0;
 		for (var l = 0; l < numPlayers; l++)
 		{
 			isConnected[4*numPlayers][l+2*numPlayers] = 1;
 			sX = sX + playerX[l];
 			sZ = sZ + playerZ[l];
 		}
 
 		var fx = fractionToTiles(sX/numPlayers);
 		var fz = fractionToTiles(sZ/numPlayers);
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[4*numPlayers]=ix;
 		IslandZ[4*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.36);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		//centeral island id numPlayers
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 		isConnected[e+2*numPlayers][e] = 1;
 		if (e+2*numPlayers+1<numIslands-numPlayers-1)
 		{
 			isConnected[e+2*numPlayers][e+2*numPlayers+1] = 1;
 		}
 		else
 		{
 			isConnected[2*numPlayers][e+2*numPlayers] = 1;
 		}
 
 		var fx = fractionToTiles(0.5 + 0.16*cos(startAngle + e*TWO_PI/numPlayers));
 		var fz = fractionToTiles(0.5 + 0.16*sin(startAngle + e*TWO_PI/numPlayers));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+2*numPlayers]=ix;
 		IslandZ[e+2*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.81);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 		//Small Isles
 		isConnected[e+3*numPlayers][e+numPlayers] = 1;
 		var fx = fractionToTiles(0.5 + 0.27*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var fz = fractionToTiles(0.5 + 0.27*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+3*numPlayers]=ix;
 		IslandZ[e+3*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.49);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 			isConnected[e][e+numPlayers] = 1;
 			if (e+1<numPlayers)
 			{
 				isConnected[e + 1][e+numPlayers] = 1;
 			}
 			else
 			{
 				isConnected[0][e+numPlayers] = 1;
 			}
 
 			//second island id 4
 			var fx = fractionToTiles(0.5 + 0.41*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var fz = fractionToTiles(0.5 + 0.41*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var ix = round(fx);
 			var iz = round(fz);
 			IslandX[e+numPlayers]=ix;
 			IslandZ[e+numPlayers]=iz;
 			// calculate size based on the radius
 			var hillSize = PI * radius * radius;
 
 			// create the hill
 			var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 			var terrainPainter = new LayeredPainter(
 				[tCliff, tHill],		// terrains
 				[cliffRadius]		// widths
 			);
 			var elevationPainter = new SmoothElevationPainter(
 				ELEVATION_SET,			// type
 				elevation,				// elevation
 				cliffRadius				// blend radius
 			);
 			createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 	}
 		//3 PLAYERS
 		//-----------------
 		//-----------------
 		if (numPlayers == 3){
 		numIslands = 4*numPlayers+1;
 		var IslandX = new Array(numIslands);
 		var IslandZ = new Array(numIslands);
 		var isConnected = new Array(numIslands);
 		for (var q=0; q <numIslands; q++)
 		{
 			isConnected[q]=new Array(numIslands);
 		}
 		for (var m = 0; m < numIslands; m++){
 			for (var n = 0; n < numIslands; n++){
 				isConnected[m][n] = 0;
 			}
 		}
 		//connections
 		var sX = 0;
 		var sZ = 0;
 		for (var l = 0; l < numPlayers; l++)
 		{
 			isConnected[4*numPlayers][l+2*numPlayers] = 1;
 			sX = sX + playerX[l];
 			sZ = sZ + playerZ[l];
 		}
 
 		var fx = fractionToTiles(sX/numPlayers);
 		var fz = fractionToTiles(sZ/numPlayers);
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[4*numPlayers]=ix;
 		IslandZ[4*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.36);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		//centeral island id numPlayers
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 		isConnected[e+2*numPlayers][e] = 1;
 		if (e+2*numPlayers+1<numIslands-numPlayers-1)
 		{
 			isConnected[e+2*numPlayers][e+2*numPlayers+1] = 1;
 		}
 		else
 		{
 			isConnected[2*numPlayers][e+2*numPlayers] = 1;
 		}
 
 		var fx = fractionToTiles(0.5 + 0.16*cos(startAngle + e*TWO_PI/numPlayers));
 		var fz = fractionToTiles(0.5 + 0.16*sin(startAngle + e*TWO_PI/numPlayers));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+2*numPlayers]=ix;
 		IslandZ[e+2*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.81);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 		//Small Isles
 		isConnected[e+3*numPlayers][e+numPlayers] = 1;
 		var fx = fractionToTiles(0.5 + 0.27*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var fz = fractionToTiles(0.5 + 0.27*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+3*numPlayers]=ix;
 		IslandZ[e+3*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.49);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 			isConnected[e][e+numPlayers] = 1;
 			if (e+1<numPlayers)
 			{
 				isConnected[e + 1][e+numPlayers] = 1;
 			}
 			else
 			{
 				isConnected[0][e+numPlayers] = 1;
 			}
 
 			//second island id 4
 			var fx = fractionToTiles(0.5 + 0.41*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var fz = fractionToTiles(0.5 + 0.41*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var ix = round(fx);
 			var iz = round(fz);
 			IslandX[e+numPlayers]=ix;
 			IslandZ[e+numPlayers]=iz;
 			// calculate size based on the radius
 			var hillSize = PI * radius * radius;
 
 			// create the hill
 			var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 			var terrainPainter = new LayeredPainter(
 				[tCliff, tHill],		// terrains
 				[cliffRadius]		// widths
 			);
 			var elevationPainter = new SmoothElevationPainter(
 				ELEVATION_SET,			// type
 				elevation,				// elevation
 				cliffRadius				// blend radius
 			);
 			createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 	}
 
 		//4 PLAYERS
 		//-----------------
 		//-----------------
 		if (numPlayers == 4){
 		numIslands = 4*numPlayers+1;
 		var IslandX = new Array(numIslands);
 		var IslandZ = new Array(numIslands);
 		var isConnected = new Array(numIslands);
 		for (var q=0; q <numIslands; q++)
 		{
 			isConnected[q]=new Array(numIslands);
 		}
 		for (var m = 0; m < numIslands; m++){
 			for (var n = 0; n < numIslands; n++){
 				isConnected[m][n] = 0;
 			}
 		}
 		//connections
 		var sX = 0;
 		var sZ = 0;
 		for (var l = 0; l < numPlayers; l++)
 		{
 			isConnected[4*numPlayers][l+2*numPlayers] = 1;
 			sX = sX + playerX[l];
 			sZ = sZ + playerZ[l];
 		}
 
 		var fx = fractionToTiles(sX/numPlayers);
 		var fz = fractionToTiles(sZ/numPlayers);
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[4*numPlayers]=ix;
 		IslandZ[4*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.36);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		//centeral island id numPlayers
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 		isConnected[e+2*numPlayers][e] = 1;
 		if (e+2*numPlayers+1<numIslands-numPlayers-1)
 		{
 			isConnected[e+2*numPlayers][e+2*numPlayers+1] = 1;
 		}
 		else
 		{
 			isConnected[2*numPlayers][e+2*numPlayers] = 1;
 		}
 
 		var fx = fractionToTiles(0.5 + 0.16*cos(startAngle + e*TWO_PI/numPlayers));
 		var fz = fractionToTiles(0.5 + 0.16*sin(startAngle + e*TWO_PI/numPlayers));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+2*numPlayers]=ix;
 		IslandZ[e+2*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.81);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 		//Small Isles
 		isConnected[e+3*numPlayers][e+numPlayers] = 1;
 		var fx = fractionToTiles(0.5 + 0.41*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var fz = fractionToTiles(0.5 + 0.41*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+3*numPlayers]=ix;
 		IslandZ[e+3*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.49);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 			isConnected[e][e+numPlayers] = 1;
 			if (e+1<numPlayers)
 			{
 				isConnected[e + 1][e+numPlayers] = 1;
 			}
 			else
 			{
 				isConnected[0][e+numPlayers] = 1;
 			}
 
 			//second island id 4
 			var fx = fractionToTiles(0.5 + 0.27*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var fz = fractionToTiles(0.5 + 0.27*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var ix = round(fx);
 			var iz = round(fz);
 			IslandX[e+numPlayers]=ix;
 			IslandZ[e+numPlayers]=iz;
 			// calculate size based on the radius
 			var hillSize = PI * radius * radius;
 
 			// create the hill
 			var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 			var terrainPainter = new LayeredPainter(
 				[tCliff, tHill],		// terrains
 				[cliffRadius]		// widths
 			);
 			var elevationPainter = new SmoothElevationPainter(
 				ELEVATION_SET,			// type
 				elevation,				// elevation
 				cliffRadius				// blend radius
 			);
 			createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 	}
 
 			//More than 4 PLAYERS
 		//-----------------
 		//-----------------
 		if (numPlayers > 4){
 		numIslands = numPlayers + 1;
 		var IslandX = new Array(numIslands);
 		var IslandZ = new Array(numIslands);
 		var isConnected = new Array(numIslands);
 		for (var q=0; q <numIslands; q++)
 		{
 			isConnected[q]=new Array(numIslands);
 		}
 		for (var m = 0; m < numIslands; m++){
 			for (var n = 0; n < numIslands; n++){
 				isConnected[m][n] = 0;
 			}
 		}
 		//connections
 		var sX = 0;
 		var sZ = 0;
 		for (var l = 0; l < numPlayers; l++)
 		{
 			isConnected[l][numPlayers] = 1;
 			sX = sX + playerX[l];
 			sZ = sZ + playerZ[l];
 		}
 
 		//centeral island id numPlayers
 
 		var fx = fractionToTiles((sX)/numPlayers);
 		var fz = fractionToTiles((sZ)/numPlayers);
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[numPlayers]=ix;
 		IslandZ[numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = PI * radius * radius;
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 	}
 }
 
 //****************************
 //----------------------------
 //Medium Size
 //----------------------------
 //****************************
 if (mapSize == 256){
 		//2,3,4 PLAYERS
 		//-----------------
 		//-----------------
 		if ((numPlayers == 2)||(numPlayers == 3)||(numPlayers == 4)){
 		numIslands = 4*numPlayers+1;
 		var IslandX = new Array(numIslands);
 		var IslandZ = new Array(numIslands);
 		var isConnected = new Array(numIslands);
 		for (var q=0; q <numIslands; q++)
 		{
 			isConnected[q]=new Array(numIslands);
 		}
 		for (var m = 0; m < numIslands; m++){
 			for (var n = 0; n < numIslands; n++){
 				isConnected[m][n] = 0;
 			}
 		}
 		//connections
 		var sX = 0;
 		var sZ = 0;
 		for (var l = 0; l < numPlayers; l++)
 		{
 			isConnected[4*numPlayers][l+2*numPlayers] = 1;
 			sX = sX + playerX[l];
 			sZ = sZ + playerZ[l];
 		}
 
 		var fx = fractionToTiles(sX/numPlayers);
 		var fz = fractionToTiles(sZ/numPlayers);
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[4*numPlayers]=ix;
 		IslandZ[4*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.36);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		//centeral island id numPlayers
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 		isConnected[e+2*numPlayers][e] = 1;
 		if (e+2*numPlayers+1<numIslands-numPlayers-1)
 		{
 			isConnected[e+2*numPlayers][e+2*numPlayers+1] = 1;
 		}
 		else
 		{
 			isConnected[2*numPlayers][e+2*numPlayers] = 1;
 		}
 
 		var fx = fractionToTiles(0.5 + 0.16*cos(startAngle + e*TWO_PI/numPlayers));
 		var fz = fractionToTiles(0.5 + 0.16*sin(startAngle + e*TWO_PI/numPlayers));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+2*numPlayers]=ix;
 		IslandZ[e+2*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.81);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 		//Small Isles
 		isConnected[e+3*numPlayers][e+numPlayers] = 1;
 		var fx = fractionToTiles(0.5 + 0.41*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var fz = fractionToTiles(0.5 + 0.41*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+3*numPlayers]=ix;
 		IslandZ[e+3*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.49);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 			isConnected[e][e+numPlayers] = 1;
 			if (e+1<numPlayers)
 			{
 				isConnected[e + 1][e+numPlayers] = 1;
 			}
 			else
 			{
 				isConnected[0][e+numPlayers] = 1;
 			}
 
 			//second island id 4
 			var fx = fractionToTiles(0.5 + 0.26*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var fz = fractionToTiles(0.5 + 0.26*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var ix = round(fx);
 			var iz = round(fz);
 			IslandX[e+numPlayers]=ix;
 			IslandZ[e+numPlayers]=iz;
 			// calculate size based on the radius
 			var hillSize = PI * radius * radius;
 
 			// create the hill
 			var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 			var terrainPainter = new LayeredPainter(
 				[tCliff, tHill],		// terrains
 				[cliffRadius]		// widths
 			);
 			var elevationPainter = new SmoothElevationPainter(
 				ELEVATION_SET,			// type
 				elevation,				// elevation
 				cliffRadius				// blend radius
 			);
 			createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 	}
 
 			//More than 4 PLAYERS
 		//-----------------
 		//-----------------
 		if (numPlayers > 4){
 		numIslands = 2*numPlayers;
 		var IslandX = new Array(numIslands);
 		var IslandZ = new Array(numIslands);
 		var isConnected = new Array(numIslands);
 		for (var q=0; q <numIslands; q++)
 		{
 			isConnected[q]=new Array(numIslands);
 		}
 		for (var m = 0; m < numIslands; m++){
 			for (var n = 0; n < numIslands; n++){
 				isConnected[m][n] = 0;
 			}
 		}
 		//connections
 		var sX = 0;
 		var sZ = 0;
 
 		//centeral island id numPlayers
 		for (var e = 0; e <numPlayers; e++)
 		{
 		if (e+1<numPlayers)
 		{
 			isConnected[e][e+1] = 1;
 		}
 		else
 		{
 			isConnected[0][e] = 1;
 		}
 		isConnected[e+numPlayers][e] = 1;
 		if (e+numPlayers+1<numIslands)
 		{
 			isConnected[e+numPlayers][e+numPlayers+1] = 1;
 		}
 		else
 		{
 			isConnected[e+numPlayers][numPlayers] = 1;
 		}
 		var fx = fractionToTiles(0.5 + 0.16*cos(startAngle + e*TWO_PI/numPlayers));
 		var fz = fractionToTiles(0.5 + 0.16*sin(startAngle + e*TWO_PI/numPlayers));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+numPlayers]=ix;
 		IslandZ[e+numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.81);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 
 	}
 }
 
 //****************************
 //----------------------------
 //Normal Size
 //----------------------------
 //****************************
 if (mapSize == 320){
 		//2,3,4,5 PLAYERS
 		//-----------------
 		//-----------------
 		if ((numPlayers == 2)||(numPlayers == 3)||(numPlayers == 4)||(numPlayers == 5)){
 		numIslands = 4*numPlayers+1;
 		var IslandX = new Array(numIslands);
 		var IslandZ = new Array(numIslands);
 		var isConnected = new Array(numIslands);
 		for (var q=0; q <numIslands; q++)
 		{
 			isConnected[q]=new Array(numIslands);
 		}
 		for (var m = 0; m < numIslands; m++){
 			for (var n = 0; n < numIslands; n++){
 				isConnected[m][n] = 0;
 			}
 		}
 		//connections
 		var sX = 0;
 		var sZ = 0;
 		for (var l = 0; l < numPlayers; l++)
 		{
 			isConnected[4*numPlayers][l+2*numPlayers] = 1;
 			sX = sX + playerX[l];
 			sZ = sZ + playerZ[l];
 		}
 
 		var fx = fractionToTiles(sX/numPlayers);
 		var fz = fractionToTiles(sZ/numPlayers);
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[4*numPlayers]=ix;
 		IslandZ[4*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.36);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		//centeral island id numPlayers
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 		isConnected[e+2*numPlayers][e] = 1;
 		if (e+2*numPlayers+1<numIslands-numPlayers-1)
 		{
 			isConnected[e+2*numPlayers][e+2*numPlayers+1] = 1;
 		}
 		else
 		{
 			isConnected[2*numPlayers][e+2*numPlayers] = 1;
 		}
 
 		var fx = fractionToTiles(0.5 + 0.16*cos(startAngle + e*TWO_PI/numPlayers));
 		var fz = fractionToTiles(0.5 + 0.16*sin(startAngle + e*TWO_PI/numPlayers));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+2*numPlayers]=ix;
 		IslandZ[e+2*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.81);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 		//Small Isles
 		isConnected[e+3*numPlayers][e+numPlayers] = 1;
 		var fx = fractionToTiles(0.5 + 0.41*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var fz = fractionToTiles(0.5 + 0.41*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+3*numPlayers]=ix;
 		IslandZ[e+3*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.49);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 			isConnected[e][e+numPlayers] = 1;
 			if (e+1<numPlayers)
 			{
 				isConnected[e + 1][e+numPlayers] = 1;
 			}
 			else
 			{
 				isConnected[0][e+numPlayers] = 1;
 			}
 
 			//second island id 4
 			var fx = fractionToTiles(0.5 + 0.26*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var fz = fractionToTiles(0.5 + 0.26*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var ix = round(fx);
 			var iz = round(fz);
 			IslandX[e+numPlayers]=ix;
 			IslandZ[e+numPlayers]=iz;
 			// calculate size based on the radius
 			var hillSize = PI * radius * radius;
 
 			// create the hill
 			var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 			var terrainPainter = new LayeredPainter(
 				[tCliff, tHill],		// terrains
 				[cliffRadius]		// widths
 			);
 			var elevationPainter = new SmoothElevationPainter(
 				ELEVATION_SET,			// type
 				elevation,				// elevation
 				cliffRadius				// blend radius
 			);
 			createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 	}
 
 		//6,7 PLAYERS
 		//-----------------
 		//-----------------
 		if ((numPlayers == 6)||(numPlayers == 7)){
 		numIslands = 4*numPlayers+1;
 		var IslandX = new Array(numIslands);
 		var IslandZ = new Array(numIslands);
 		var isConnected = new Array(numIslands);
 		for (var q=0; q <numIslands; q++)
 		{
 			isConnected[q]=new Array(numIslands);
 		}
 		for (var m = 0; m < numIslands; m++){
 			for (var n = 0; n < numIslands; n++){
 				isConnected[m][n] = 0;
 			}
 		}
 		//connections
 		var sX = 0;
 		var sZ = 0;
 		for (var l = 0; l < numPlayers; l++)
 		{
 			isConnected[4*numPlayers][l+2*numPlayers] = 1;
 			sX = sX + playerX[l];
 			sZ = sZ + playerZ[l];
 		}
 
 		var fx = fractionToTiles(sX/numPlayers);
 		var fz = fractionToTiles(sZ/numPlayers);
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[4*numPlayers]=ix;
 		IslandZ[4*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.36);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		//centeral island id numPlayers
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 		isConnected[e+2*numPlayers][e] = 1;
 		if (e+2*numPlayers+1<numIslands-numPlayers-1)
 		{
 			isConnected[e+2*numPlayers][e+2*numPlayers+1] = 1;
 		}
 		else
 		{
 			isConnected[2*numPlayers][e+2*numPlayers] = 1;
 		}
 
 		var fx = fractionToTiles(0.5 + 0.16*cos(startAngle + e*TWO_PI/numPlayers));
 		var fz = fractionToTiles(0.5 + 0.16*sin(startAngle + e*TWO_PI/numPlayers));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+2*numPlayers]=ix;
 		IslandZ[e+2*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.81);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 		//Small Isles
 		isConnected[e+3*numPlayers][e+numPlayers] = 1;
 		var fx = fractionToTiles(0.5 + 0.41*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var fz = fractionToTiles(0.5 + 0.41*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+3*numPlayers]=ix;
 		IslandZ[e+3*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.49);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 			isConnected[e][e+numPlayers] = 1;
 			if (e+1<numPlayers)
 			{
 				isConnected[e + 1][e+numPlayers] = 1;
 			}
 			else
 			{
 				isConnected[0][e+numPlayers] = 1;
 			}
 
 			//second island id 4
 			var fx = fractionToTiles(0.5 + 0.26*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var fz = fractionToTiles(0.5 + 0.26*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var ix = round(fx);
 			var iz = round(fz);
 			IslandX[e+numPlayers]=ix;
 			IslandZ[e+numPlayers]=iz;
 			// calculate size based on the radius
 			var hillSize = PI * radius * radius;
 
 			// create the hill
 			var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 			var terrainPainter = new LayeredPainter(
 				[tCliff, tHill],		// terrains
 				[cliffRadius]		// widths
 			);
 			var elevationPainter = new SmoothElevationPainter(
 				ELEVATION_SET,			// type
 				elevation,				// elevation
 				cliffRadius				// blend radius
 			);
 			createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 	}
 		//8 PLAYERS
 		//-----------------
 		//-----------------
 		if (numPlayers == 8){
 		numIslands = 2*numPlayers;
 		var IslandX = new Array(numIslands);
 		var IslandZ = new Array(numIslands);
 		var isConnected = new Array(numIslands);
 		for (var q=0; q <numIslands; q++)
 		{
 			isConnected[q]=new Array(numIslands);
 		}
 		for (var m = 0; m < numIslands; m++){
 			for (var n = 0; n < numIslands; n++){
 				isConnected[m][n] = 0;
 			}
 		}
 		//connections
 		var sX = 0;
 		var sZ = 0;
 
 		//centeral island id numPlayers
 		for (var e = 0; e <numPlayers; e++)
 		{
 		if (e+1<numPlayers)
 		{
 			isConnected[e][e+1] = 1;
 		}
 		else
 		{
 			isConnected[0][e] = 1;
 		}
 		isConnected[e+numPlayers][e] = 1;
 		if (e+numPlayers+1<numIslands)
 		{
 			isConnected[e+numPlayers][e+numPlayers+1] = 1;
 		}
 		else
 		{
 			isConnected[e+numPlayers][numPlayers] = 1;
 		}
 		var fx = fractionToTiles(0.5 + 0.16*cos(startAngle + e*TWO_PI/numPlayers));
 		var fz = fractionToTiles(0.5 + 0.16*sin(startAngle + e*TWO_PI/numPlayers));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+numPlayers]=ix;
 		IslandZ[e+numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.81);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 
 	}
 }
 
 //****************************
 //----------------------------
 //Large and larger Sizes
 //----------------------------
 //****************************
 if (mapSize > 383){
 		//2,3,4,5 PLAYERS
 		//-----------------
 		//-----------------
 		if ((numPlayers == 2)||(numPlayers == 3)||(numPlayers == 4)||(numPlayers == 5)){
 		numIslands = 4*numPlayers+1;
 		var IslandX = new Array(numIslands);
 		var IslandZ = new Array(numIslands);
 		var isConnected = new Array(numIslands);
 		for (var q=0; q <numIslands; q++)
 		{
 			isConnected[q]=new Array(numIslands);
 		}
 		for (var m = 0; m < numIslands; m++){
 			for (var n = 0; n < numIslands; n++){
 				isConnected[m][n] = 0;
 			}
 		}
 		//connections
 		var sX = 0;
 		var sZ = 0;
 		for (var l = 0; l < numPlayers; l++)
 		{
 			isConnected[4*numPlayers][l+2*numPlayers] = 1;
 			sX = sX + playerX[l];
 			sZ = sZ + playerZ[l];
 		}
 
 		var fx = fractionToTiles(sX/numPlayers);
 		var fz = fractionToTiles(sZ/numPlayers);
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[4*numPlayers]=ix;
 		IslandZ[4*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.36);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		//centeral island id numPlayers
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 		isConnected[e+2*numPlayers][e] = 1;
 		if (e+2*numPlayers+1<numIslands-numPlayers-1)
 		{
 			isConnected[e+2*numPlayers][e+2*numPlayers+1] = 1;
 		}
 		else
 		{
 			isConnected[2*numPlayers][e+2*numPlayers] = 1;
 		}
 
 		var fx = fractionToTiles(0.5 + 0.16*cos(startAngle + e*TWO_PI/numPlayers));
 		var fz = fractionToTiles(0.5 + 0.16*sin(startAngle + e*TWO_PI/numPlayers));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+2*numPlayers]=ix;
 		IslandZ[e+2*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.81);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 		//Small Isles
 		isConnected[e+3*numPlayers][e+numPlayers] = 1;
 		var fx = fractionToTiles(0.5 + 0.41*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var fz = fractionToTiles(0.5 + 0.41*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+3*numPlayers]=ix;
 		IslandZ[e+3*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.49);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 			isConnected[e][e+numPlayers] = 1;
 			if (e+1<numPlayers)
 			{
 				isConnected[e + 1][e+numPlayers] = 1;
 			}
 			else
 			{
 				isConnected[0][e+numPlayers] = 1;
 			}
 
 			//second island id 4
 			var fx = fractionToTiles(0.5 + 0.24*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var fz = fractionToTiles(0.5 + 0.24*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var ix = round(fx);
 			var iz = round(fz);
 			IslandX[e+numPlayers]=ix;
 			IslandZ[e+numPlayers]=iz;
 			// calculate size based on the radius
 			var hillSize = PI * radius * radius;
 
 			// create the hill
 			var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 			var terrainPainter = new LayeredPainter(
 				[tCliff, tHill],		// terrains
 				[cliffRadius]		// widths
 			);
 			var elevationPainter = new SmoothElevationPainter(
 				ELEVATION_SET,			// type
 				elevation,				// elevation
 				cliffRadius				// blend radius
 			);
 			createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 
 	}
 
 		//6,7,8 PLAYERS
 		//-----------------
 		//-----------------
 		if ((numPlayers == 6)||(numPlayers == 7)||(numPlayers == 8)){
 		numIslands = 4*numPlayers+1;
 		var IslandX = new Array(numIslands);
 		var IslandZ = new Array(numIslands);
 		var isConnected = new Array(numIslands);
 		for (var q=0; q <numIslands; q++)
 		{
 			isConnected[q]=new Array(numIslands);
 		}
 		for (var m = 0; m < numIslands; m++){
 			for (var n = 0; n < numIslands; n++){
 				isConnected[m][n] = 0;
 			}
 		}
 		//connections
 		var sX = 0;
 		var sZ = 0;
 		for (var l = 0; l < numPlayers; l++)
 		{
 			isConnected[4*numPlayers][l+2*numPlayers] = 1;
 			sX = sX + playerX[l];
 			sZ = sZ + playerZ[l];
 		}
 
 		var fx = fractionToTiles(sX/numPlayers);
 		var fz = fractionToTiles(sZ/numPlayers);
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[4*numPlayers]=ix;
 		IslandZ[4*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.36);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 		//centeral island id numPlayers
 		for (var e = 0; e <numPlayers; e++)
 		{
 		isConnected[e+2*numPlayers][e] = 1;
 		if (e+2*numPlayers+1<numIslands-numPlayers-1)
 		{
 			isConnected[e+2*numPlayers][e+2*numPlayers+1] = 1;
 		}
 		else
 		{
 			isConnected[2*numPlayers][e+2*numPlayers] = 1;
 		}
 
 		var fx = fractionToTiles(0.5 + 0.16*cos(startAngle + e*TWO_PI/numPlayers));
 		var fz = fractionToTiles(0.5 + 0.16*sin(startAngle + e*TWO_PI/numPlayers));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+2*numPlayers]=ix;
 		IslandZ[e+2*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.81);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 		//Small Isles
 		isConnected[e+3*numPlayers][e+numPlayers] = 1;
 		var fx = fractionToTiles(0.5 + 0.41*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var fz = fractionToTiles(0.5 + 0.41*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+3*numPlayers]=ix;
 		IslandZ[e+3*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.36);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 			isConnected[e][e+numPlayers] = 1;
 			if (e+1<numPlayers)
 			{
 				isConnected[e + 1][e+numPlayers] = 1;
 			}
 			else
 			{
 				isConnected[0][e+numPlayers] = 1;
 			}
 
 			//second island id 4
 			var fx = fractionToTiles(0.5 + 0.28*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var fz = fractionToTiles(0.5 + 0.28*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var ix = round(fx);
 			var iz = round(fz);
 			IslandX[e+numPlayers]=ix;
 			IslandZ[e+numPlayers]=iz;
 			// calculate size based on the radius
 			var hillSize = PI * radius * radius * 0.81;
 
 			// create the hill
 			var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 			var terrainPainter = new LayeredPainter(
 				[tCliff, tHill],		// terrains
 				[cliffRadius]		// widths
 			);
 			var elevationPainter = new SmoothElevationPainter(
 				ELEVATION_SET,			// type
 				elevation,				// elevation
 				cliffRadius				// blend radius
 			);
 			createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 
 	}
 }
 
 for (var m = 0; m < numIslands; m++){
 	for (var n = 0; n < numIslands; n++){
 		if(isConnected[m][n] == 1){
 			isConnected[n][m] = 1;
 		}
 	}
 }
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 		IslandX[i]=ix;
 		IslandZ[i]=iz;
 	// calculate size based on the radius
 	var hillSize = PI * radius * radius;
 
 	// create the hill
 	var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 	var terrainPainter = new LayeredPainter(
 		[tCliff, tHill],		// terrains
 		[cliffRadius]		// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		elevation,				// elevation
 		cliffRadius				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clPlayer)], null);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tRoadWild, tRoad], [1]);
 	createArea(placer, painter, null);
 
 	placeCivDefaultEntities(fx, fz, id, { 'iberWall': 'towers' });
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 10;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oFruitBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 		mAngle = randFloat(0, TWO_PI);
 
 	var mDist = radius - 4;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var num = floor(hillSize / 60);
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = 11;
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oTree1, num, num, 0,4)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, [avoidClasses(clBaseResource,2), stayClasses(clPlayer, 3)]);
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 
 RMS.SetProgress(30);
 
 //Create connectors
 for (var ix = 0; ix < mapSize; ix++)
 	for (var iz = 0; iz < mapSize; iz++)
 		for (var m = 0; m < numIslands; m++)
 			for (var n = 0; n < numIslands; n++)
 				if(isConnected[m][n] == 1)
 				{
 					var a = IslandZ[m]-IslandZ[n];
 					var b = IslandX[n]-IslandX[m];
 					var c = (IslandZ[m]*(IslandX[m]-IslandX[n]))-(IslandX[m]*(IslandZ[m]-IslandZ[n]));
 					var dis = abs(a*ix + b*iz + c)/sqrt(a*a + b*b);
 					var k = (a*ix + b*iz + c)/(a*a + b*b);
 					var y = iz-(b*k);
 					if((dis < 5)&&(y <= Math.max(IslandZ[m],IslandZ[n]))&&(y >= Math.min(IslandZ[m],IslandZ[n])))
 					{
 						if (dis < 3)
 						{
 							var h = 20;
 							if (dis < 2)
 								var t = tHill;
 							else
 								var t = tCliff;
 							addToClass(ix, iz, clLand);
 						}
 						else
 						{
 							var h = 50 - 10 * dis;
 							var t = tCliff;
 							addToClass(ix, iz, clLand);
 						}
 
 						if (getHeight(ix, iz)<h)
 						{
 							placeTerrain(ix, iz, t);
 							setHeight(ix, iz, h);
 						}
 					}
 				}
 
 // calculate desired number of trees for map (based on size)
 if (currentBiome() == "savanna")
 {
 	var MIN_TREES = 200;
 	var MAX_TREES = 1250;
 	var P_FOREST = 0.02;
 }
 else if (currentBiome() == "tropic")
 {
 	var MIN_TREES = 1000;
 	var MAX_TREES = 6000;
 	var P_FOREST = 0.6;
 }
 else
 {
 	var MIN_TREES = 500;
 	var MAX_TREES = 3000;
 	var P_FOREST = 0.7;
 }
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 var numForest = totalTrees * P_FOREST;
 var numStragglers = totalTrees * (1.0 - P_FOREST);
 
 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...");
 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, 5)],
 	5*scaleByMapSize(4,16), 100
 );
 
 log("Creating small stone quarries...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 10, clRock, 10, clHill, 1), stayClasses(clLand, 5)],
 	5*scaleByMapSize(4,16), 100
 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 10, clMetal, 10, clRock, 5, clHill, 1), stayClasses(clLand, 5)],
 	5*scaleByMapSize(4,16), 100
 );
 
 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(
 	[new SimpleObject(aRockMedium, 1,3, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 4)],
 	scaleByMapSize(16, 262), 50
 );
 
 log("Creating large decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 4)],
 	scaleByMapSize(8, 131), 50
 );
 
 RMS.SetProgress(70);
 
 log("Creating deer...");
 group = new SimpleGroup(
 	[new SimpleObject(oMainHuntableAnimal, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 10, clHill, 1, clFood, 20), stayClasses(clLand, 4)],
 	3 * numPlayers, 50
 );
 
 RMS.SetProgress(75);
 
 log("Creating sheep...");
 group = new SimpleGroup(
 	[new SimpleObject(oSecondaryHuntableAnimal, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 10, clHill, 1, clFood, 20), stayClasses(clLand, 4)],
 	3 * numPlayers, 50
 );
 
 log("Creating fruits...");
 group = new SimpleGroup(
 	[new SimpleObject(oFruitBush, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 10, clHill, 1, clFood, 20), stayClasses(clLand, 4)],
 	3 * numPlayers, 50
 );
 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")
 	planetm = 8;
 
 log("Creating small grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)]
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clHill, 2, clPlayer, 2, clDirt, 0), stayClasses(clLand, 4)],
 	planetm * 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,
 	[avoidClasses(clHill, 2, clPlayer, 2, clDirt, 1, clForest, 0), stayClasses(clLand, 4)],
 	planetm * 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,
 	[avoidClasses(clHill, 1, clPlayer, 1, clDirt, 1), stayClasses(clLand, 4)],
 	planetm * scaleByMapSize(13, 200), 50
 );
 
 setSkySet(pickRandom(["cirrus", "cumulus", "sunny"]));
 setSunRotation(randFloat(0, TWO_PI));
 setSunElevation(randFloat(PI/ 5, PI / 3));
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/schwarzwald.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/schwarzwald.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/schwarzwald.js	(revision 20301)
@@ -1,411 +1,410 @@
 RMS.LoadLibrary('rmgen');
 RMS.LoadLibrary("heightmap");
 
 log('Initializing map...');
 
 InitMap();
 
 setSkySet("fog");
 setFogFactor(0.35);
 setFogThickness(0.19);
 
 setWaterColor(0.501961, 0.501961, 0.501961);
 setWaterTint(0.25098, 0.501961, 0.501961);
 setWaterWaviness(0.5);
 setWaterType("clap");
 setWaterMurkiness(0.75);
 
 setPPSaturation(0.37);
 setPPContrast(0.4);
 setPPBrightness(0.4);
 setPPEffect("hdr");
 setPPBloom(0.4);
 
 var clPlayer = createTileClass();
 var clPath = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clOpen = createTileClass();
 
 var templateStoneMine = 'gaia/geology_stonemine_alpine_quarry';
 var templateMetalMine = 'gaia/geology_metal_alpine_slabs';
 var startingResources = ['gaia/flora_tree_pine', 'gaia/flora_tree_pine','gaia/flora_tree_pine', templateStoneMine,
 	'gaia/flora_bush_grapes', 'gaia/flora_tree_aleppo_pine','gaia/flora_tree_aleppo_pine','gaia/flora_tree_aleppo_pine', 'gaia/flora_bush_berry', templateMetalMine];
 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';
 var aRockMedium = 'actor|geology/stone_granite_med.xml';
 var aBushMedium = 'actor|props/flora/bush_medit_me.xml';
 var aBushSmall = 'actor|props/flora/bush_medit_sm.xml';
 var aReeds = 'actor|props/flora/reeds_pond_lush_b.xml';
 var oFish = "gaia/fauna_fish";
 
 var terrainWood = ['alpine_forrestfloor|gaia/flora_tree_oak', 'alpine_forrestfloor|gaia/flora_tree_pine'];
 
 var terrainWoodBorder = ['new_alpine_grass_mossy|gaia/flora_tree_oak', 'alpine_forrestfloor|gaia/flora_tree_pine',
 	'temp_grass_long|gaia/flora_bush_temperate', 'temp_grass_clovers|gaia/flora_bush_berry', 'temp_grass_clovers_2|gaia/flora_bush_grapes',
 	'temp_grass_plants|gaia/fauna_deer', 'temp_grass_plants|gaia/fauna_rabbit', 'new_alpine_grass_dirt_a'];
 
 var terrainBase = ['temp_plants_bog', 'temp_grass_plants', 'temp_grass_d', 'temp_grass_plants',
 	'temp_plants_bog', 'temp_grass_plants', 'temp_grass_plants',
 	'temp_plants_bog', 'temp_grass_plants', 'temp_grass_plants',
 	'temp_plants_bog', 'temp_grass_plants', 'temp_grass_plants',
 	'temp_plants_bog', 'temp_grass_plants', 'temp_grass_plants',
 	'temp_plants_bog', 'temp_grass_plants', 'temp_grass_plants',
 	'temp_plants_bog', 'temp_grass_plants', 'temp_grass_d', 'temp_grass_plants',
 	'temp_plants_bog', 'temp_grass_plants', 'temp_grass_d', 'temp_grass_plants',
 	'temp_plants_bog', 'temp_grass_plants', 'temp_grass_d', 'temp_grass_plants',
 	'temp_plants_bog', 'temp_grass_plants', 'temp_grass_d', 'temp_grass_plants',
 	'temp_plants_bog', 'temp_grass_plants', 'temp_grass_d', 'temp_grass_plants',
 	'temp_plants_bog', 'temp_grass_plants', 'temp_grass_plants', 'temp_grass_plants|gaia/fauna_sheep'];
 
 var terrainBaseBorder = ['temp_plants_bog', 'temp_grass_plants', 'temp_grass_d', 'temp_grass_plants',
 	'temp_plants_bog', 'temp_grass_plants', 'temp_grass_plants',
 	'temp_plants_bog', 'temp_grass_plants', 'temp_grass_plants',
 	'temp_plants_bog', 'temp_grass_plants', 'temp_grass_plants',
 	'temp_plants_bog', 'temp_grass_plants', 'temp_grass_plants',
 	'temp_plants_bog', 'temp_grass_plants', 'temp_grass_plants',
 	'temp_plants_bog', 'temp_grass_plants', 'temp_grass_d', 'temp_grass_plants',
 	'temp_plants_bog', 'temp_grass_plants', 'temp_grass_d', 'temp_grass_plants',
 	'temp_plants_bog', 'temp_grass_plants', 'temp_grass_d', 'temp_grass_plants',
 	'temp_plants_bog', 'temp_grass_plants', 'temp_grass_d', 'temp_grass_plants',
 	'temp_plants_bog', 'temp_grass_plants', 'temp_grass_d', 'temp_grass_plants',
 	'temp_plants_bog', 'temp_grass_plants', 'temp_grass_plants'];
 
 var baseTex = ['temp_road', 'temp_road_overgrown'];
 
 var terrainPath = ['temp_road', 'temp_road_overgrown'];
 
 var tWater = ['dirt_brown_d'];
 var tWaterBorder = ['dirt_brown_d'];
 
 var mapSize = getMapSize();
 var mapRadius = mapSize/2;
 var playableMapRadius = mapRadius - 5;
 var mapCenterX = mapRadius;
 var mapCenterZ = mapRadius;
 
 var numPlayers = getNumPlayers();
 var baseRadius = 15;
 var minPlayerRadius = min(mapRadius-1.5*baseRadius, 5*mapRadius/8);
 var maxPlayerRadius = min(mapRadius-baseRadius, 3*mapRadius/4);
 
 var playerStartLocX = [];
 var playerStartLocZ = [];
 var playerAngle = [];
 var playerAngleStart = randFloat(0, 2*PI);
 var playerAngleAddAvrg = 2*PI / numPlayers;
 var playerAngleMaxOff = playerAngleAddAvrg/4;
 
 var pathSucsessRadius = baseRadius/2;
 var pathAngleOff = PI/2;
 var pathWidth = 10; // This is not really the path's thickness in tiles but the number of tiles in the clumbs of the path
 
 var resourceRadius = 2/3 * mapRadius;
 
 // Setup woods
 // For large maps there are memory errors with too many trees.  A density of 256*192/mapArea works with 0 players.
 // Around each player there is an area without trees so with more players the max density can increase a bit.
 var maxTreeDensity = min(256 * (192 + 8 * numPlayers) / (mapSize * mapSize), 1); // Has to be tweeked but works ok
 var bushChance = 1/3; // 1 means 50% chance in deepest wood, 0.5 means 25% chance in deepest wood
 
 ////////////////
 //
 //  Some general functions
 //
 ////////////////
 
 function HeightPlacer(lowerBound, upperBound) {
     this.lowerBound = lowerBound;
     this.upperBound = upperBound;
 }
 
 HeightPlacer.prototype.place = function (constraint) {
 	constraint = (constraint || new NullConstraint());
 
     var ret = [];
     for (var x = 0; x < g_Map.size; x++) {
         for (var y = 0; y < g_Map.size; y++) {
             if (g_Map.height[x][y] >= this.lowerBound && g_Map.height[x][y] <= this.upperBound && constraint.allows(x, y)) {
                 ret.push(new PointXZ(x, y));
             }
         }
     }
     return ret;
 };
 
 ////////////////
 // Set height limits and water level by map size
 ////////////////
 
 // Set target min and max height depending on map size to make average steepness about the same on all map sizes
 var heightRange = {'min': MIN_HEIGHT * (g_Map.size + 512) / 8192, 'max': MAX_HEIGHT * (g_Map.size + 512) / 8192, 'avg': (MIN_HEIGHT * (g_Map.size + 512) +MAX_HEIGHT * (g_Map.size + 512))/16384};
 
 // Set average water coverage
 var averageWaterCoverage = 1/5; // NOTE: Since erosion is not predictable actual water coverage might vary much with the same values
 var waterHeight = -MIN_HEIGHT + heightRange.min + averageWaterCoverage * (heightRange.max - heightRange.min);
 var waterHeightAdjusted = waterHeight + MIN_HEIGHT;
 setWaterHeight(waterHeight);
 
 ////////////////
 // Generate base terrain
 ////////////////
 
 // Setting a 3x3 Grid as initial heightmap
 var initialReliefmap = [[heightRange.max, heightRange.max, heightRange.max], [heightRange.max, heightRange.min, heightRange.max], [heightRange.max, heightRange.max, heightRange.max]];
 
 setBaseTerrainDiamondSquare(heightRange.min, heightRange.max, initialReliefmap);
 // Apply simple erosion
 for (var i = 0; i < 5; i++)
 	globalSmoothHeightmap();
 rescaleHeightmap(heightRange.min, heightRange.max);
 
 RMS.SetProgress(50);
 
 //////////
 // Setup height limit
 //////////
 
 // Height presets
 var heighLimits = [
 	heightRange.min + 1/3 * (waterHeightAdjusted - heightRange.min), // 0 Deep water
 	heightRange.min + 2/3 * (waterHeightAdjusted - heightRange.min), // 1 Medium Water
 	heightRange.min + (waterHeightAdjusted - heightRange.min), // 2 Shallow water
 	waterHeightAdjusted + 1/8 * (heightRange.max - waterHeightAdjusted), // 3 Shore
 	waterHeightAdjusted + 2/8 * (heightRange.max - waterHeightAdjusted), // 4 Low ground
 	waterHeightAdjusted + 3/8 * (heightRange.max - waterHeightAdjusted), // 5 Player and path height
 	waterHeightAdjusted + 4/8 * (heightRange.max - waterHeightAdjusted), // 6 High ground
 	waterHeightAdjusted + 5/8 * (heightRange.max - waterHeightAdjusted), // 7 Lower forest border
 	waterHeightAdjusted + 6/8 * (heightRange.max - waterHeightAdjusted), // 8 Forest
 	waterHeightAdjusted + 7/8 * (heightRange.max - waterHeightAdjusted), // 9 Upper forest border
 	waterHeightAdjusted + (heightRange.max - waterHeightAdjusted)]; // 10 Hilltop
 
 //////////
 // Place start locations and apply terrain texture and decorative props
 //////////
 
 // Get start locations
 var startLocations = getStartLocationsByHeightmap({'min': heighLimits[4], 'max': heighLimits[5]});
 
 var playerHeight = (heighLimits[4] + heighLimits[5]) / 2;
 
 for (var i=0; i < numPlayers; i++)
 {
 	playerAngle[i] = (playerAngleStart + i*playerAngleAddAvrg + randFloat(0, playerAngleMaxOff))%(2*PI);
 
 	var x = round(mapCenterX + randFloat(minPlayerRadius, maxPlayerRadius)*cos(playerAngle[i]));
 	var z = round(mapCenterZ + randFloat(minPlayerRadius, maxPlayerRadius)*sin(playerAngle[i]));
 
 	playerStartLocX[i] = x;
 	playerStartLocZ[i] = z;
 
 	rectangularSmoothToHeight({"x": x,"y": z} , 20, 20, playerHeight, 0.8);
 
 	placeCivDefaultEntities(x, z, i+1, { 'iberWall': false });
 
 	// Place base texture
 	var placer = new ClumpPlacer(2*baseRadius*baseRadius, 2/3, 1/8, 10, x, z);
 	var painter = [new TerrainPainter([baseTex], [baseRadius/4, baseRadius/4]), paintClass(clPlayer)];
 	createArea(placer, painter);
 
 	// Place starting resources
 	var distToSL = 15;
 	var resStartAngle = playerAngle[i] + PI;
 	var resAddAngle = 2*PI / startingResources.length;
 	for (var rIndex = 0; rIndex < startingResources.length; rIndex++)
 	{
 		var angleOff = randFloat(-resAddAngle/2, resAddAngle/2);
 		var placeX = x + distToSL*cos(resStartAngle + rIndex*resAddAngle + angleOff);
 		var placeZ = z + distToSL*sin(resStartAngle + rIndex*resAddAngle + angleOff);
 		placeObject(placeX, placeZ, startingResources[rIndex], 0, randFloat(0, 2*PI));
 		addToClass(round(placeX), round(placeZ), clBaseResource);
 	}
 }
 
 // Add further stone and metal mines
 distributeEntitiesByHeight({ 'min': heighLimits[3], 'max': ((heighLimits[4] + heighLimits[3]) / 2) }, startLocations, 40, [templateStoneMine, templateMetalMine]);
 distributeEntitiesByHeight({ 'min': ((heighLimits[5] + heighLimits[6]) / 2), 'max': heighLimits[7] }, startLocations, 40, [templateStoneMine, templateMetalMine]);
 
 RMS.SetProgress(50);
 
 //place water & open terrain textures and assign TileClasses
 log("Painting textures...");
 var placer = new HeightPlacer(heighLimits[2], (heighLimits[3]+heighLimits[2])/2);
 var painter = new LayeredPainter([terrainBase, terrainBaseBorder], [5]);
 createArea(placer, painter);
 paintTileClassBasedOnHeight(heighLimits[2], (heighLimits[3]+heighLimits[2])/2, 1, clOpen);
 
 var placer = new HeightPlacer(heightRange.min, heighLimits[2]);
 var painter = new LayeredPainter([tWaterBorder, tWater], [2]);
 createArea(placer, painter);
 paintTileClassBasedOnHeight(heightRange.min,  heighLimits[2], 1, clWater);
 
 RMS.SetProgress(60);
 
 log("Placing paths...");
 
 var doublePaths = true;
 if (numPlayers > 4)
 	doublePaths = false;
 
 if (doublePaths === true)
 	var maxI = numPlayers+1;
 else
 	var maxI = numPlayers;
 
 for (var i = 0; i < maxI; i++)
 {
 	if (doublePaths === true)
 		var minJ = 0;
 	else
 		var minJ = i+1;
 
 	for (var j = minJ; j < numPlayers+1; j++)
 	{
 		// Setup start and target coordinates
 		if (i < numPlayers)
 		{
 			var x = playerStartLocX[i];
 			var z = playerStartLocZ[i];
 		}
 		else
 		{
 			var x = mapCenterX;
 			var z = mapCenterZ;
 		}
 
 		if (j < numPlayers)
 		{
 			var targetX = playerStartLocX[j];
 			var targetZ = playerStartLocZ[j];
 		}
 		else
 		{
 			var targetX = mapCenterX;
 			var targetZ = mapCenterZ;
 		}
 
 		// Prepare path placement
 		var angle = getAngle(x, z, targetX, targetZ);
 		x += round(pathSucsessRadius*cos(angle));
 		z += round(pathSucsessRadius*sin(angle));
 
 		var targetReached = false;
 		var tries = 0;
 
 		// Placing paths
 		while (targetReached === false && tries < 2*mapSize)
 		{
 			var placer = new ClumpPlacer(pathWidth, 1, 1, 1, x, z);
 			var painter = [new TerrainPainter(terrainPath), new SmoothElevationPainter(ELEVATION_MODIFY, -0.1, 1.0), paintClass(clPath)];
 			createArea(placer, painter, avoidClasses(clPath, 0, clOpen, 0 ,clWater, 4, clBaseResource, 4));
 
 			// addToClass(x, z, clPath); // Not needed...
 			// Set vars for next loop
 			angle = getAngle(x, z, targetX, targetZ);
 			if (doublePaths === true) // Bended paths
 			{
 				x += round(cos(angle + randFloat(-pathAngleOff/2, 3*pathAngleOff/2)));
 				z += round(sin(angle + randFloat(-pathAngleOff/2, 3*pathAngleOff/2)));
 			}
 			else // Straight paths
 			{
 				x += round(cos(angle + randFloat(-pathAngleOff, pathAngleOff)));
 				z += round(sin(angle + randFloat(-pathAngleOff, pathAngleOff)));
 			}
 
 			if (getDistance(x, z, targetX, targetZ) < pathSucsessRadius)
 				targetReached = true;
 
 			tries++;
 		}
 	}
 }
 
 RMS.SetProgress(75);
 
 log("Creating decoration...");
 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),
   scaleByMapSize(13, 200),
   scaleByMapSize(13, 200),
   scaleByMapSize(13, 200)
  ],
  avoidClasses(clForest, 1, clPlayer, 0, clPath, 3, clWater, 3)
 );
 
 RMS.SetProgress(80);
 
 log("Growing fish...");
 createFood
 (
  [
   [new SimpleObject(oFish, 2,3, 0,2)]
  ],
  [
   100 * numPlayers
  ],
  [avoidClasses(clFood, 5), stayClasses(clWater, 4)]
 );
 
 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);
 
 log("Planting trees...");
 for (var x = 0; x < mapSize; x++)
 {
 	for (var z = 0;z < mapSize;z++)
 	{
 		var radius = Math.pow(Math.pow(mapCenterX - x - 0.5, 2) + Math.pow(mapCenterZ - z - 0.5, 2), 1/2); // The 0.5 is a correction for the entities placed on the center of tiles
 		var minDistToSL = mapSize;
 		for (var i=0; i < numPlayers; i++)
 			minDistToSL = min(minDistToSL, getDistance(playerStartLocX[i], playerStartLocZ[i], x, z));
 
 		// Woods tile based
 		var tDensFactSL = max(min((minDistToSL - baseRadius) / baseRadius, 1), 0);
 		var tDensFactRad = abs((resourceRadius - radius) / resourceRadius);
 		var tDensActual = (maxTreeDensity * tDensFactSL * tDensFactRad)*0.75;
 
 		if (randBool(tDensActual) && radius < playableMapRadius)
 		{
 			if (tDensActual < randFloat(0, bushChance * maxTreeDensity))
 			{
 				var placer = new ClumpPlacer(1, 1.0, 1.0, 1, x, z);
 				var painter = [new TerrainPainter(terrainWoodBorder), paintClass(clForest)];
 				createArea(placer, painter, avoidClasses(clPath, 1, clOpen, 2, clWater,3));
 			}
 			else
 			{
 				var placer = new ClumpPlacer(1, 1.0, 1.0, 1, x, z);
 				var painter = [new TerrainPainter(terrainWood), paintClass(clForest)];
 				createArea(placer, painter, avoidClasses(clPath, 2, clOpen, 3, clWater, 4));}
 		}
 	}
 }
 
 RMS.SetProgress(100);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/the_nile.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/the_nile.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/the_nile.js	(revision 20301)
@@ -1,493 +1,473 @@
 RMS.LoadLibrary("rmgen");
 
 var tCity = "desert_city_tile";
 var tCityPlaza = "desert_city_tile_plaza";
 var tFineSand = "desert_sand_smooth";
 var tForestFloor = "desert_forestfloor_palms";
 var tGrass = "desert_dirt_rough_2";
 var tGrassSand50 = "desert_sand_dunes_50";
 var tGrassSand25 = "desert_dirt_rough";
 var tDirt = "desert_dirt_rough";
 var tDirtCracks = "desert_dirt_cracks";
 var tShore = "desert_sand_wet";
 var tLush = "desert_grass_a";
 var tSLush = "desert_grass_a_sand";
 var tSDry = "desert_plants_b";
 
 var oBerryBush = "gaia/flora_bush_berry";
 var oCamel = "gaia/fauna_camel";
 var oGazelle = "gaia/fauna_gazelle";
 var oGoat = "gaia/fauna_goat";
 var oStoneLarge = "gaia/geology_stonemine_desert_badlands_quarry";
 var oStoneSmall = "gaia/geology_stone_desert_small";
 var oMetalLarge = "gaia/geology_metal_desert_slabs";
 var oDatePalm = "gaia/flora_tree_date_palm";
 var oSDatePalm = "gaia/flora_tree_cretan_date_palm_short";
 var eObelisk = "other/obelisk";
 var ePyramid = "other/pyramid_minor";
 var oWood = "gaia/special_treasure_wood";
 var oFood = "gaia/special_treasure_food_bin";
 
 var aBush1 = "actor|props/flora/bush_desert_a.xml";
 var aBush2 = "actor|props/flora/bush_desert_dry_a.xml";
 var aBush3 = "actor|props/flora/bush_medit_sm_dry.xml";
 var aBush4 = "actor|props/flora/plant_desert_a.xml";
 var aDecorativeRock = "actor|geology/stone_desert_med.xml";
 var aReeds = "actor|props/flora/reeds_pond_lush_a.xml";
 var aLillies = "actor|props/flora/water_lillies.xml";
 
 var pForest = [tForestFloor + TERRAIN_SEPARATOR + oDatePalm, tForestFloor + TERRAIN_SEPARATOR + oSDatePalm, tForestFloor];
 
 InitMap();
 
 var mapSize = getMapSize();
 var aPlants = mapSize < 256 ?
 	"actor|props/flora/grass_tropical.xml" :
 	"actor|props/flora/grass_tropic_field_tall.xml";
 
 var numPlayers = getNumPlayers();
 
 var clPlayer = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clGrass = createTileClass();
 var clDesert = createTileClass();
 var clPond = createTileClass();
 var clShore = createTileClass();
 var clTreasure = createTileClass();
 
 var playerIDs = primeSortAllPlayers();
 var playerPos = placePlayersRiver();
 var playerX = [];
 var playerZ = [];
 
 for (var i = 0; i < numPlayers; i++)
 {
 	playerZ[i] = playerPos[i];
 	playerX[i] = 0.30 + 0.4*(i%2);
 }
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = floor(fx);
 	var iz = floor(fz);
 	addToClass(ix, iz, clPlayer);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	var placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tCityPlaza, tCity], [1]);
 	createArea(placer, painter, null);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oBerryBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 		mAngle = randFloat(0, TWO_PI);
 	var mDist = radius - 4;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var num = 2;
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(11, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oDatePalm, num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aBush1, clBaseResource, radius);
 }
 
 RMS.SetProgress(30);
 
 const riverTextures = [
 	{
 		"left": 0,
 		"right": 0.04,
 		"tileClass": tLush
 	},
 	{
 		"left": 0.04,
 		"right": 0.06,
 		"tileClass": tSLush
 	},
 	{
 		"left": 0.06,
 		"right": 0.09,
 		"tileClass": tSDry
 	}
 ];
 
 const plantFrequency = 2;
 
 var plantID = 0;
 
 paintRiver({
 	"horizontal": false,
 	"parallel": true,
 	"position": 0.5,
 	"width": 0.1,
 	"fadeDist": 0.025,
 	"deviation": 0.005,
 	"waterHeight": -3,
 	"landHeight": 2,
 	"meanderShort": 12,
 	"meanderLong": 50,
 	"waterFunc": (ix, iz, height) => {
 
 		addToClass(ix, iz, clWater);
 		placeTerrain(ix, iz, tShore);
 
 		// Place river bushes
 		if (height <= -0.2 || height >= 0.1)
 			return;
 
 		if (plantID % plantFrequency == 0)
 		{
 			plantID = 0;
 			placeObject(ix, iz, aPlants, 0, randFloat(0, TWO_PI));
 		}
 		++plantID;
 	},
 	"landFunc": (ix, iz, shoreDist1, shoreDist2) => {
 
 		let x = ix / (mapSize + 1.0);
 		if (x < 0.25 || x > 0.75)
 			addToClass(ix, iz, clDesert);
 
 		for (let riv of riverTextures)
 			if (-shoreDist1 > -riv.right && -shoreDist1 < -riv.left ||
 				-shoreDist2 > riv.left && -shoreDist2 < riv.right)
 			{
 				placeTerrain(ix, iz, riv.tileClass);
 				addToClass(ix, iz, clShore);
 			}
 	}
 });
 
 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 = [];
 
 // calculate desired number of trees for map (based on size)
 const MIN_TREES = 700;
 const MAX_TREES = 3500;
 const P_FOREST = 0.5;
 
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 var numForest = totalTrees * P_FOREST;
 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
 );
 
 log("Creating small stone quarries...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 1, clPlayer, 20, clRock, 10, clWater, 1, clPond, 1),
 	scaleByMapSize(4,16), 100
 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clWater, 1, clPond, 1),
 	scaleByMapSize(4,16), 100
 );
 
 log("Creating stone mines...");
 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), stayClasses(clDesert, 3)],
 	scaleByMapSize(6,20), 100
 );
 
 log("Creating small stone quarries...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 20, clRock, 10, clWater, 1, clPond, 1), stayClasses(clDesert, 3)],
 	scaleByMapSize(6,20), 100
 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clWater, 1, clPond, 1), stayClasses(clDesert, 3)],
 	scaleByMapSize(6,20), 100
 );
 
 RMS.SetProgress(65);
 
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aDecorativeRock, 1,3, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clWater, 1, clForest, 0, clPlayer, 0, clPond, 1),
 	scaleByMapSize(16, 262), 50
 );
 
 log("Creating shrubs...");
 group = new SimpleGroup(
 	[new SimpleObject(aBush2, 1,2, 0,1), new SimpleObject(aBush1, 1,3, 0,2), new SimpleObject(aBush4, 1,2, 0,1), new SimpleObject(aBush3, 1,3, 0,2)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clWater, 1, clPlayer, 0, clPond, 1),
 	scaleByMapSize(20, 180), 50
 );
 RMS.SetProgress(70);
 
 log("Creating gazelles...");
 group = new SimpleGroup([new SimpleObject(oGazelle, 5,7, 0,4)], true, clFood);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 20, clWater, 1, clFood, 10, clDesert, 5, clPond, 1),
 	3*scaleByMapSize(5,20), 50
 );
 
 log("Creating goats...");
 group = new SimpleGroup([new SimpleObject(oGoat, 2,4, 0,3)], true, clFood);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 20, clWater, 1, clFood, 10, clDesert, 5, clPond, 1),
 	3*scaleByMapSize(5,20), 50
 );
 
 log("Creating treasures...");
 group = new SimpleGroup([new SimpleObject(oFood, 1,1, 0,2)], true, clTreasure);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 20, clWater, 1, clFood, 2, clDesert, 5, clTreasure, 6, clPond, 1),
 	3*scaleByMapSize(5,20), 50
 );
 
 group = new SimpleGroup([new SimpleObject(oWood, 1,1, 0,2)], true, clTreasure);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 20, clWater, 1, clFood, 2, clDesert, 5, clTreasure, 6, clPond, 1),
 	3*scaleByMapSize(5,20), 50
 );
 
 log("Creating camels...");
 group = new SimpleGroup([new SimpleObject(oCamel, 2,4, 0,2)], true, clFood);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 20, clWater, 1, clFood, 10, clDesert, 5, clTreasure, 2, clPond, 1),
 	3*scaleByMapSize(5,20), 50
 );
 
 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(
 	[new SimpleObject(eObelisk, 1,1, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	[avoidClasses(clWater, 4, clForest, 3, clPlayer, 20, clMetal, 6, clRock, 2, clPond, 4, clTreasure, 2), stayClasses(clDesert, 3)],
 	scaleByMapSize(5, 30), 50
 );
 
 log("Creating pyramids");
 group = new SimpleGroup(
 	[new SimpleObject(ePyramid, 1,1, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	[avoidClasses(clWater, 7, clForest, 6, clPlayer, 20, clMetal, 5, clRock, 5, clPond, 7, clTreasure, 2), stayClasses(clDesert, 3)],
 	scaleByMapSize(2, 6), 50
 );
 
 setSkySet("sunny");
 setSunColor(0.711, 0.746, 0.574);
 setWaterColor(0.541,0.506,0.416);
 setWaterTint(0.694,0.592,0.522);
 setWaterMurkiness(1);
 setWaterWaviness(3.0);
 setWaterType("lake");
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/volcanic_lands.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/volcanic_lands.js	(revision 20300)
+++ ps/trunk/binaries/data/mods/public/maps/random/volcanic_lands.js	(revision 20301)
@@ -1,266 +1,239 @@
 RMS.LoadLibrary("rmgen");
 
 var tGrass = ["cliff volcanic light", "ocean_rock_a", "ocean_rock_b"];
 var tGrassA = "cliff volcanic light";
 var tGrassB = "ocean_rock_a";
 var tGrassC = "ocean_rock_b";
 var tCliff = ["cliff volcanic coarse", "cave_walls"];
 var tRoad = "road1";
 var tRoadWild = "road1";
 var tLava1 = "LavaTest05";
 var tLava2 = "LavaTest04";
 var tLava3 = "LavaTest03";
 
 var oTree = "gaia/flora_tree_dead";
 var oStoneLarge = "gaia/geology_stonemine_alpine_quarry";
 var oStoneSmall = "gaia/geology_stone_alpine_a";
 var oMetalLarge = "gaia/geology_metal_alpine_slabs";
 
 var aRockLarge = "actor|geology/stone_granite_med.xml";
 var aRockMedium = "actor|geology/stone_granite_med.xml";
 
 var pForestD = [tGrassC + TERRAIN_SEPARATOR + oTree, tGrassC];
 var pForestP = [tGrassB + TERRAIN_SEPARATOR + oTree, tGrassB];
 
 InitMap();
 
 var numPlayers = getNumPlayers();
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clBaseResource = createTileClass();
 
 var [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 	addCivicCenterAreaToClass(ix, iz, clPlayer);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	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);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	// create metal mine
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 		mAngle = randFloat(0, TWO_PI);
 
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var hillSize = PI * radius * radius;
 	var num = floor(hillSize / 60);
 	var tries = 10;
 	for (var x = 0; x < tries; ++x)
 	{
 		var tAngle = randFloat(-PI/3, 4*PI/3);
 		var tDist = randFloat(12, 13);
 		var tX = round(fx + tDist * cos(tAngle));
 		var tZ = round(fz + tDist * sin(tAngle));
 		group = new SimpleGroup(
 			[new SimpleObject(oTree, num, num, 0, 3)],
 			false, clBaseResource, tX, tZ
 		);
 		if (createObjectGroup(group, 0, avoidClasses(clBaseResource, 2)))
 			break;
 	}
 }
 RMS.SetProgress(15);
 
 createVolcano(0.5, 0.5, clHill, tCliff, [tLava1, tLava2, tLava3], true, ELEVATION_SET);
 RMS.SetProgress(45);
 
 log("Creating hills...");
 createAreas(
 	new ClumpPlacer(scaleByMapSize(20, 150), 0.2, 0.1, 1),
 	[
 		new LayeredPainter([tCliff, tGrass], [2]),
 		new SmoothElevationPainter(ELEVATION_SET, 18, 2),
 		paintClass(clHill)
 	],
 	avoidClasses(clPlayer, 12, clHill, 15, clBaseResource, 2),
 	scaleByMapSize(2, 8) * numPlayers
 );
 
 // calculate desired number of trees for map (based on size)
 var MIN_TREES = 200;
 var MAX_TREES = 1250;
 var P_FOREST = 0.7;
 
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 var numForest = totalTrees * P_FOREST;
 var numStragglers = totalTrees * (1.0 - P_FOREST);
 
 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)
-	);
-}
-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
-	);
+		scaleByMapSize(20, 80));
+
+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([tGrassB, tGrassB], [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(
-		[tGrassC,tGrassC], 		// terrains
-		[1]															// widths
-	);
+		scaleByMapSize(20, 80));
+
+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([tGrassC, tGrassC], [1]),
+			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
 );
 
 log("Creating small stone mines...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 1, clPlayer, 10, clRock, 10, clHill, 1),
 	scaleByMapSize(4,16), 100
 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 1, clPlayer, 10, clMetal, 10, clRock, 5, clHill, 1),
 	scaleByMapSize(4,16), 100
 );
 
 RMS.SetProgress(90);
 
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockMedium, 1,3, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clForest, 0, clPlayer, 0, clHill, 0),
 	scaleByMapSize(16, 262), 50
 );
 
 log("Creating large decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clForest, 0, clPlayer, 0, clHill, 0),
 	scaleByMapSize(8, 131), 50
 );
 
 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();