Index: ps/trunk/binaries/data/mods/public/maps/random/aegean_sea.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/aegean_sea.js	(revision 20531)
+++ ps/trunk/binaries/data/mods/public/maps/random/aegean_sea.js	(revision 20532)
@@ -1,351 +1,357 @@
 Engine.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, playerX, playerZ] = playerPlacementRiver(0, 0.6);
 
 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);
 }
 Engine.SetProgress(30);
 
 paintRiver({
 	"parallel": false,
 	"startX": 0.5,
 	"startZ": 0,
 	"endX": 0.5,
 	"endZ": 1,
 	"width": 0.35,
 	"fadeDist": 0.025,
 	"deviation": 0,
 	"waterHeight": -3,
 	"landHeight": 2,
 	"meanderShort": 20,
 	"meanderLong": 0,
 	"waterFunc": (ix, iz, height, riverFraction) => {
 
 		if (height < 0.7)
 			addToClass(ix, iz, clWater);
 	}
 });
 
 paintTerrainBasedOnHeight(-20, 1, 0, tWater);
 paintTerrainBasedOnHeight(1, 2, 0, tShore);
 
 Engine.SetProgress(40);
 createBumps(avoidClasses(clWater, 2, clPlayer, 20));
 
 var [forestTrees, stragglerTrees] = getTreeCounts(500, 3000, 0.7);
 createForests(
  [tForestFloor, tForestFloor, tForestFloor, pForest, pForest],
  avoidClasses(clPlayer, 20, clForest, 17, clWater, 2, clBaseResource, 3),
  clForest,
  forestTrees);
 
 Engine.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),
  scaleByMapSize(15, 45),
  clDirt);
 
 Engine.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),
  scaleByMapSize(15, 45),
  clDirt);
 
 Engine.SetProgress(60);
 
 log("Creating undersea bumps...");
 createAreas(
 	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...");
 createAreas(
 	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),
  clRock);
 
 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),
  clRock);
 
 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
 );
 
 Engine.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)
-);
+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));
 
 Engine.SetProgress(70);
 
 createFood(
 	[
 		[new SimpleObject(oFish, 2, 3, 0, 2)]
 	],
 	[
 		3 * scaleByMapSize(5, 20)
 	],
 	[avoidClasses(clIsland, 2, clFood, 10), stayClasses(clWater, 5)],
 	clFood);
 
 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),
 	clFood);
 
 createFood(
 	[
 		[new SimpleObject(oBerryBush, 5, 7, 0, 4)]
 	],
 	[
 		3 * numPlayers
 	],
 	avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 10),
 	clFood);
 
 Engine.SetProgress(90);
 
 var types = [oDatePalm, oSDatePalm, oCarob, oFanPalm, oPoplar, oCypress];
 createStragglerTrees(
 	types,
 	avoidClasses(clForest, 1, clWater, 2, clPlayer, 12, clMetal, 6, clHill, 1),
 	clForest,
 	stragglerTrees);
 
 createStragglerTrees(
 	types,
 	stayClasses(clIsland, 4),
 	clForest,
 	stragglerTrees * 10);
 
 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 20531)
+++ ps/trunk/binaries/data/mods/public/maps/random/african_plains.js	(revision 20532)
@@ -1,326 +1,325 @@
 Engine.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();
 Engine.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();
 
 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, oStoneSmall, 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));
 }
 Engine.SetProgress(20);
 
 createHills([tDirt2, tCliff, tGrassShrubs], avoidClasses(clPlayer, 35, clForest, 20, clHill, 20, clWater, 2), clHill, scaleByMapSize(5, 8));
 Engine.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...");
 createAreas(
 	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)
 );
 Engine.SetProgress(45);
 
 paintTerrainBasedOnHeight(3, floor(scaleByMapSize(20, 40)), 0, tCliff);
 paintTerrainBasedOnHeight(floor(scaleByMapSize(20, 40)), 100, 3, tGrass);
 
 createBumps(avoidClasses(clWater, 2, clPlayer, 20));
 
 var [forestTrees, stragglerTrees] = getTreeCounts(500, 3000, 0.7);
 createForests(
 	[tPrimary, tForestFloor, tForestFloor, pForest, pForest],
 	avoidClasses(clPlayer, 20, clForest, 20, clHill, 0, clWater, 2),
 	clForest,
 	forestTrees);
 
 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),
 	scaleByMapSize(15, 45),
 	clDirt);
 
 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),
 	scaleByMapSize(15, 45),
 	clDirt);
 
 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),
 	scaleByMapSize(15, 45),
 	clDirt);
 Engine.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),
 	clRock);
 
 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
 );
 Engine.SetProgress(70);
 
 createDecoration(
 	[
 		[new SimpleObject(aBush, 1,3, 0,1)],
 		[new SimpleObject(aRock, 1,2, 0,1)]
 	],
 	[
 		scaleByMapSize(8, 131),
 		scaleByMapSize(8, 131)
 	],
-	avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0)
-);
+	avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0));
 Engine.SetProgress(75);
 
 log("Creating giraffes...");
 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),
 	clFood);
 
 createFood(
 	[
 		[new SimpleObject(oCrocodile, 2, 3, 0, 3)]
 	],
 	[
 		3 * numPlayers,
 	],
 	stayClasses(clWater, 6),
 	clFood);
 
 createFood(
 	[
 		[new SimpleObject(oBerryBush, 5, 7, 0, 4)]
 	],
 	[
 		randIntInclusive(1, 4) * numPlayers + 2
 	],
 	avoidClasses(clWater, 3, clForest, 2, clPlayer, 20, clHill, 3, clFood, 10),
 	clFood);
 
 createFood(
 	[
 		[new SimpleObject(oFish, 2, 3, 0, 2)]
 	],
 	[
 		15 * numPlayers
 	],
 	[avoidClasses(clFood, 20), stayClasses(clWater, 6)],
 	clFood);
 Engine.SetProgress(85);
 
 createStragglerTrees(
 	[oBaobab],
 	avoidClasses(clWater, 5, clForest, 2, clHill, 3, clPlayer, 12, clMetal, 4, clRock, 4),
 	clForest,
 	stragglerTrees);
 
 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/alpine_lakes.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/alpine_lakes.js	(revision 20531)
+++ ps/trunk/binaries/data/mods/public/maps/random/alpine_lakes.js	(revision 20532)
@@ -1,355 +1,354 @@
 Engine.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);
 }
 
 Engine.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)));
 
 Engine.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);
 
 	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));
 
 var [forestTrees, stragglerTrees] = getTreeCounts(500, 3000, 0.7);
 createForests(
  [tPrimary, tForestFloor, tForestFloor, pForest, pForest],
  avoidClasses(clPlayer, 20, clForest, 17, clHill, 0, clWater, 2),
  clForest,
  forestTrees);
 
 Engine.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),
  scaleByMapSize(15, 45),
  clDirt);
 
 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),
  scaleByMapSize(15, 45),
  clDirt);
 Engine.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),
  clRock);
 
 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
 );
 
 Engine.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)
-);
+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),
+		scaleByMapSize(13, 200),
+		scaleByMapSize(13, 200),
+		scaleByMapSize(13, 200)
+	],
+	avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0));
 
 Engine.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),
 	clFood);
 
 createFood(
 	[
 		[new SimpleObject(oBerryBush, 5, 7, 0, 4)]
 	],
 	[
 		randIntInclusive(1, 4) * numPlayers + 2
 	],
 	avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 10),
 	clFood);
 
 createFood(
 	[
 		[new SimpleObject(oFish, 2, 3, 0, 2)]
 	],
 	[
 		15 * numPlayers
 	],
 	[avoidClasses(clFood, 20), stayClasses(clWater, 6)],
 	clFood);
 
 Engine.SetProgress(85);
 
 createStragglerTrees(
 	[oPine],
 	avoidClasses(clWater, 5, clForest, 3, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6),
 	clForest,
 	stragglerTrees);
 
 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/archipelago.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/archipelago.js	(revision 20531)
+++ ps/trunk/binaries/data/mods/public/maps/random/archipelago.js	(revision 20532)
@@ -1,307 +1,306 @@
 Engine.LoadLibrary("rmgen");
 Engine.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 oWoodTreasure = "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 landHeight = 3;
 var shoreHeight = 1;
 
 var islandRadius = scaleByMapSize(22, 31);
 
 var [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 log("Creating player islands...");
 for (let i = 0; i < numPlayers; ++i)
 	createArea(
 		new ChainPlacer(
 			2,
 			Math.floor(scaleByMapSize(5, 10)),
 			Math.floor(scaleByMapSize(25, 60)),
 			1,
 			Math.floor(fractionToTiles(playerX[i])),
 			Math.floor(fractionToTiles(playerZ[i])),
 			0,
 			[Math.floor(islandRadius)]),
 		new SmoothElevationPainter(ELEVATION_SET, landHeight, 4));
 
 log("Creating random islands...");
 createAreas(
 	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, landHeight, 4),
 		paintClass(clLand)
 	],
 	null,
 	scaleByMapSize(1, 5) * randIntInclusive(5, 10));
 
 paintTerrainBasedOnHeight(landHeight - 0.6, landHeight + 0.4, 3, tMainTerrain);
 paintTerrainBasedOnHeight(shoreHeight, landHeight, 0, tShore);
 paintTerrainBasedOnHeight(getMapBaseHeight(), shoreHeight, 2, tWater);
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = islandRadius;
 
 	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);
 
 	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(oWoodTreasure, 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);
 
 	// 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)]);
 }
 
 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);
 
 var [forestTrees, stragglerTrees] = getTreeCounts(...rBiomeTreeCount(1));
 createForests(
  [tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
  [avoidClasses(clPlayer, 20, clForest, 17, clHill, 0), stayClasses(clLand, 4)],
  clForest,
  forestTrees);
 Engine.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)],
  scaleByMapSize(15, 45),
  clDirt);
 
 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)],
  scaleByMapSize(15, 45),
  clDirt);
 Engine.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)],
  clRock
 );
 
 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
 );
 Engine.SetProgress(65);
 
 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)]
-);
+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),
+		planetm * scaleByMapSize(13, 200),
+		planetm * scaleByMapSize(13, 200),
+		planetm * scaleByMapSize(13, 200)
+	],
+	[avoidClasses(clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 5)]);
 Engine.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, 1, clHill, 1, clFood, 20), stayClasses(clLand, 3)],
 	clFood);
 
 Engine.SetProgress(75);
 
 createFood(
 	[
 		[new SimpleObject(oFruitBush, 5, 7, 0, 4)]
 	],
 	[
 		3 * numPlayers
 	],
 	[avoidClasses(clForest, 0, clPlayer, 1, clHill, 1, clFood, 10), stayClasses(clLand, 3)],
 	clFood);
 
 Engine.SetProgress(80);
 
 createFood(
 	[
 		[new SimpleObject(oFish, 2, 3, 0, 2)]
 	],
 	[
 		25 * numPlayers
 	],
 	avoidClasses(clLand, 3, clPlayer, 2, clFood, 20),
 	clFood);
 
 Engine.SetProgress(85);
 
 createStragglerTrees(
 	[oTree1, oTree2, oTree4, oTree3],
 	[avoidClasses(clForest, 7, clHill, 1, clPlayer, 3, clMetal, 6, clRock, 6), stayClasses(clLand, 7)],
 	clForest,
 	stragglerTrees);
 
 setWaterWaviness(4.0);
 setWaterType("ocean");
 
 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 20531)
+++ ps/trunk/binaries/data/mods/public/maps/random/atlas_mountains.js	(revision 20532)
@@ -1,271 +1,270 @@
 Engine.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 oWoodTreasure = "gaia/special_treasure_wood";
 const oFoodTreasure = "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);
 }
 
 Engine.SetProgress(10);
 
 createBumps(avoidClasses(clPlayer, 9));
 
 createMountains(tCliff, avoidClasses(clPlayer, 20, clHill, 8), clHill, scaleByMapSize(20, 120));
 
 Engine.SetProgress(25);
 
 var [forestTrees, stragglerTrees] = getTreeCounts(500, 3000, 0.7);
 createForests(
  [tGrass, tForestFloor, tForestFloor, pForest1, pForest2],
  avoidClasses(clPlayer, 20, clForest, 14, clHill, 1),
  clForest,
  forestTrees);
 
 Engine.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),
  scaleByMapSize(15, 45),
  clDirt);
 
 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),
  scaleByMapSize(15, 45),
  clDirt);
 
 Engine.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),
  clRock);
 
 log("Creating metal mines...");
 createMines(
  [
   [new SimpleObject(oMetalLarge, 1,1, 0,4)]
  ],
  avoidClasses(clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 2),
  clMetal
 );
 
 Engine.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)
-);
+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),
+		scaleByMapSize(13, 200),
+		scaleByMapSize(13, 200),
+		scaleByMapSize(13, 200)
+	],
+	avoidClasses(clForest, 0, clPlayer, 0, clHill, 0));
 
 Engine.SetProgress(75);
 
 createFood(
 	[
 		[new SimpleObject(oSheep, 5, 7, 0, 4)],
 		[new SimpleObject(oDeer, 2, 3, 0, 2)]
 	],
 	[
 		3 * numPlayers,
 		3 * numPlayers
 	],
 	avoidClasses(clForest, 0, clPlayer, 20, clHill, 1, clFood, 20),
 	clFood);
 
 createFood(
 	[
 		[new SimpleObject(oBerryBush, 5, 7, 0, 4)]
 	],
 	[
 		randIntInclusive(3, 12) * numPlayers + 2
 	],
 	avoidClasses(clForest, 0, clPlayer, 20, clHill, 1, clFood, 10),
 	clFood);
 
 log("Creating food treasures...");
 var group = new SimpleGroup(
 	[new SimpleObject(oFoodTreasure, 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(oWoodTreasure, 2,3, 0,2)],
 	true, clTreasure
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 18, clHill, 1),
 	3 * numPlayers, 50
 );
 
 Engine.SetProgress(80);
 
 createStragglerTrees(
 	[oCarob, oAleppoPine],
 	avoidClasses(clForest, 1, clHill, 1, clPlayer, 10, clMetal, 6, clRock, 6, clTreasure, 4),
 	clForest,
 	stragglerTrees);
 
 createStragglerTrees(
 	[aCarob, aAleppoPine],
 	stayClasses(clHill, 2),
 	clForest,
 	stragglerTrees / 5);
 
 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 20531)
+++ ps/trunk/binaries/data/mods/public/maps/random/cantabrian_highlands.js	(revision 20532)
@@ -1,332 +1,331 @@
 Engine.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 playerHillElevation = 20;
 
 var rampDist = scaleByMapSize(15, 25);
 var rampLength = 15;
 var rampWidth = 12;
 var rampOffset = 3;
 
 var [playerIDs, playerX, playerZ, playerAngle] = radialPlayerPlacement();
 
 log("Creating player hills and ramps...");
 for (let i = 0; i < numPlayers; ++i)
 {
 	let fx = fractionToTiles(playerX[i]);
 	let fz = fractionToTiles(playerZ[i]);
 
 	createArea(
 		new ClumpPlacer(diskArea(scaleByMapSize(15, 25)), 0.95, 0.6, 10, Math.round(fx), Math.round(fz)),
 		[
 			new LayeredPainter([tCliff, tHill], [2]),
 			new SmoothElevationPainter(ELEVATION_SET, playerHillElevation, 2),
 			paintClass(clPlayer)
 		],
 		null);
 
 	let rampAngle = playerAngle[i] + Math.PI * (1 + randFloat(-1, 1) / 8);
 	createRamp(
 		Math.round(fx + (rampDist + rampLength) * Math.cos(rampAngle)),
 		Math.round(fz + (rampDist + rampLength) * Math.sin(rampAngle)),
 		Math.round(fx + (rampDist - rampOffset) * Math.cos(rampAngle)),
 		Math.round(fz + (rampDist - rampOffset) * Math.sin(rampAngle)),
 		3,
 		playerHillElevation,
 		rampWidth,
 		2,
 		tHill,
 		tCliff,
 		clPlayer);
 }
 
 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);
 
 	// 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 = 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);
 }
 Engine.SetProgress(10);
 
 log("Creating lakes...");
 var numLakes = round(scaleByMapSize(1,4) * numPlayers);
 var waterAreas = createAreas(
 	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
 );
 Engine.SetProgress(15);
 
 log("Creating reeds...");
 var 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
 );
 Engine.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
 );
 Engine.SetProgress(25);
 
 createBumps(avoidClasses(clWater, 2, clPlayer, 0));
 Engine.SetProgress(30);
 
 log("Creating hills...");
 createHills([tCliff, tCliff, tHill], avoidClasses(clPlayer, 2, clWater, 5, clHill, 15), clHill, scaleByMapSize(1, 4) * numPlayers);
 Engine.SetProgress(35);
 
 var [forestTrees, stragglerTrees] = getTreeCounts(500, 3000, 0.7);
 createForests(
  [tGrass, tGrassDForest, tGrassPForest, pForestP, pForestD],
  avoidClasses(clPlayer, 1, clWater, 3, clForest, 17, clHill, 1),
  clForest,
  forestTrees);
 Engine.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),
  scaleByMapSize(15, 45),
  clDirt);
 Engine.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),
  scaleByMapSize(15, 45),
  clDirt);
 Engine.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),
  clRock);
 Engine.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
 );
 Engine.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)
-);
+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),
+		scaleByMapSize(13, 200),
+		scaleByMapSize(13, 200),
+		scaleByMapSize(13, 200)
+	],
+	avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0));
 Engine.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),
 	clFood);
 Engine.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),
 	clFood);
 Engine.SetProgress(85);
 
 createStragglerTrees(
 	[oOak, oOakLarge, oPine, oApple],
 	avoidClasses(clWater, 1, clForest, 1, clHill, 1, clPlayer, 1, clMetal, 6, clRock, 6),
 	clForest,
 	stragglerTrees);
 Engine.SetProgress(90);
 
 setSkySet("cirrus");
 setWaterColor(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 20531)
+++ ps/trunk/binaries/data/mods/public/maps/random/canyon.js	(revision 20532)
@@ -1,417 +1,416 @@
 Engine.LoadLibrary("rmgen");
 Engine.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 oWoodTreasure = "gaia/special_treasure_wood";
 const oFoodTreasure = "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();
 
 var landHeight = 3;
 var hillHeight = 30;
 
 var playerCanyonRadius = scaleByMapSize(18, 32);
 
 initTerrain(tMainTerrain);
 
 var [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 log("Reserving space for the players, their initial forests and some less space therein without trees...");
 for (let i = 0; i < numPlayers; ++i)
 	for (let j = 1; j <= 2; ++j)
 	createArea(
 		new ClumpPlacer(
 			diskArea(playerCanyonRadius / j),
 			0.65,
 			0.1,
 			10,
 			Math.round(fractionToTiles(playerX[i])),
 			Math.round(fractionToTiles(playerZ[i]))),
 		[
 			new LayeredPainter([tMainTerrain, tMainTerrain], [2]),
 			new SmoothElevationPainter(ELEVATION_SET, landHeight, 2),
 			paintClass(j == 1 ? clLand : clPlayer)
 		],
 		null);
 
 var radius = playerCanyonRadius;
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 
 	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);
 }
 
 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 (let g = 0; g < scaleByMapSize(5, 30); ++g)
 {
 	var tx = randIntInclusive(1, mapSize - 1);
 	var tz = randIntInclusive(1, mapSize - 1);
 
 	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 (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 (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;
 			}
 		}
 
 		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)
 			createArea(
 				new PathPlacer(tx, tz, mapSize * playerX[p2], mapSize * playerZ[p2], scaleByMapSize(11, 17), 0.4, 3 * scaleByMapSize(1, 4), 0.1, 0.1),
 				[
 					new LayeredPainter([tMainTerrain, tMainTerrain], [3]),
 					new SmoothElevationPainter(ELEVATION_SET, landHeight, 3),
 					paintClass(clLand)
 				],
 				null);
 	}
 }
 
 for (let i = 0; i < numPlayers; ++i)
 {
 	// create the city patch
 	var cityRadius = radius/3;
 	var 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);
 }
 
 createArea(
 	new ClumpPlacer(150, 0.6, 0.3, 10, center, center),
 	new LayeredPainter([tRoad, tRoad], [1]),
 	null);
 
 Engine.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);
 
 var [forestTrees, stragglerTrees] = getTreeCounts(...rBiomeTreeCount(1));
 createForests(
  [tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
  [avoidClasses(clPlayer, 1, clForest, 15, clHill, 1, clHill2, 0), stayClasses(clLand, 4)],
  clForest,
  forestTrees);
 
 Engine.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)],
  scaleByMapSize(15, 45),
  clDirt);
 
 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)],
  scaleByMapSize(15, 45),
  clDirt);
 
 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)],
  clRock);
 
 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
 );
 
 Engine.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)
-);
+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)]
+	],
+	[
+		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...");
 var group = new SimpleGroup(
 	[new SimpleObject(aTree, 1,1, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clLand, 5),
 	scaleByMapSize(200, 800), 50
 );
 
 Engine.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)],
 	clFood);
 
 createFood(
 	[
 		[new SimpleObject(oFruitBush, 5, 7, 0, 4)]
 	],
 	[
 		3 * numPlayers
 	],
 	[avoidClasses(clForest, 0, clPlayer, 4, clHill, 1, clFood, 10, clHill2, 1), stayClasses(clLand, 3)],
 	clFood);
 
 Engine.SetProgress(85);
 
 createStragglerTrees(
 	[oTree1, oTree2, oTree4, oTree3],
 	[avoidClasses(clForest, 1, clHill, 1, clPlayer, 9, clMetal, 6, clRock, 6, clHill2, 1), stayClasses(clLand, 3)],
 	clForest,
 	stragglerTrees);
 
 log("Creating treasures...");
 for (let i = 0; i < randIntInclusive(3, 8); ++i)
 	for (let template of [oFoodTreasure, oWoodTreasure])
 		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 20531)
+++ ps/trunk/binaries/data/mods/public/maps/random/continent.js	(revision 20532)
@@ -1,308 +1,307 @@
 Engine.LoadLibrary("rmgen");
 Engine.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();
 
 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);
 
 log("Ensuring initial player land...");
 for (let i = 0; i < numPlayers; ++i)
 	createArea(
 		new ChainPlacer(
 			2,
 			Math.floor(scaleByMapSize(5, 9)),
 			Math.floor(scaleByMapSize(5, 20)),
 			1,
 			Math.round(fractionToTiles(playerX[i])),
 			Math.round(fractionToTiles(playerZ[i])),
 			0,
 			[Math.floor(scaleByMapSize(23, 50))]),
 		[
 			new SmoothElevationPainter(ELEVATION_SET, 3, 4),
 			paintClass(clLand)
 		]);
 
 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);
 
 	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);
 }
 
 Engine.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);
 
 var [forestTrees, stragglerTrees] = getTreeCounts(...rBiomeTreeCount(1));
 createForests(
  [tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
  [avoidClasses(clPlayer, 20, clForest, 17, clHill, 0, clBaseResource,2), stayClasses(clLand, 4)],
  clForest,
  forestTrees);
 
 Engine.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)],
  scaleByMapSize(15, 45),
  clDirt);
 
 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)],
  scaleByMapSize(15, 45),
  clDirt);
 Engine.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)],
  clRock);
 
 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
 );
 
 Engine.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)]
-);
+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),
+		planetm * scaleByMapSize(13, 200),
+		planetm * scaleByMapSize(13, 200),
+		planetm * scaleByMapSize(13, 200)
+	],
+	[avoidClasses(clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 5)]);
 
 Engine.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)],
 	clFood);
 
 createFood(
 	[
 		[new SimpleObject(oFruitBush, 5, 7, 0, 4)]
 	],
 	[
 		3 * numPlayers
 	],
 	[avoidClasses(clForest, 0, clPlayer, 20, clHill, 1, clFood, 10), stayClasses(clLand, 5)],
 	clFood);
 
 createFood(
 	[
 		[new SimpleObject(oFish, 2, 3, 0, 2)]
 	],
 	[
 		25 * numPlayers
 	],
 	avoidClasses(clLand, 2, clFood, 20),
 	clFood);
 
 Engine.SetProgress(85);
 
 createStragglerTrees(
 	[oTree1, oTree2, oTree4, oTree3],
 	[avoidClasses(clForest, 7, clHill, 1, clPlayer, 9, clMetal, 6, clRock, 6), stayClasses(clLand, 7)],
 	clForest,
 	stragglerTrees);
 
 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 20531)
+++ ps/trunk/binaries/data/mods/public/maps/random/corinthian_isthmus.js	(revision 20532)
@@ -1,316 +1,322 @@
 Engine.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();
 const mapCenter = getMapCenter();
 
 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;
 
 log("Creating the main river");
 var riverAngle = randFloat(0, Math.PI);
 var riverWidth = scaleByMapSize(15, 70);
 var riverStart = new Vector2D(mapCenter.x, 0).rotateAround(riverAngle, mapCenter);
 var riverEnd = new Vector2D(mapCenter.x, mapSize).rotateAround(riverAngle, mapCenter);
 
 createArea(
 	new PathPlacer(riverStart.x, riverStart.y, riverEnd.x, riverEnd.y, 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 point of [riverStart, riverEnd])
 	createArea(
 		new ClumpPlacer(Math.floor(diskArea(riverWidth / 2)), 0.95, 0.6, 10, point.x, point.y),
 		new SmoothElevationPainter(ELEVATION_SET, waterHeight, 4),
 		null);
 
 log("Creating passage connecting the two riversides...");
 var passageStart = riverStart.rotateAround(Math.PI / 2, mapCenter);
 var passageEnd = riverEnd.rotateAround(Math.PI / 2, mapCenter);
 createArea(
 	new PathPlacer(
 		passageStart.x,
 		passageStart.y,
 		passageEnd.x,
 		passageEnd.y,
 		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, playerX, playerZ] = playerPlacementRiver(riverAngle, 0.6);
 
 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);
 }
 
 Engine.SetProgress(40);
 
 createBumps(avoidClasses(clWater, 2, clPlayer, 20));
 
 var [forestTrees, stragglerTrees] = getTreeCounts(500, 3000, 0.7);
 createForests(
  [tForestFloor, tForestFloor, tForestFloor, pForest, pForest],
  avoidClasses(clPlayer, 20, clForest, 17, clWater, 2, clBaseResource, 3),
  clForest,
  forestTrees);
 
 Engine.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),
  scaleByMapSize(15, 45),
  clDirt);
 
 Engine.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),
  scaleByMapSize(15, 45),
  clDirt);
 
 Engine.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, 4, clPlayer, 15, clRock, 10, clWater, 4, clHill, 4),
  clRock);
 
 log("Creating metal mines...");
 createMines(
  [
   [new SimpleObject(oMetalLarge, 1,1, 0,4)]
  ],
  avoidClasses(clForest, 4, clPlayer, 15, clMetal, 10, clRock, 5, clWater, 4, clHill, 4),
  clMetal
 );
 
 Engine.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, 5, clBaseResource, 6, clHill, 1, clRock, 6, clMetal, 6)
-);
+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, 5, clBaseResource, 6, clHill, 1, clRock, 6, clMetal, 6));
 
 Engine.SetProgress(70);
 
 createFood(
 	[
 		[new SimpleObject(oFish, 2, 3, 0, 2)]
 	],
 	[
 		3 * scaleByMapSize(5, 20)
 	],
 	[avoidClasses(clFood, 10), stayClasses(clWater, 5)],
 	clFood);
 
 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, 10, clBaseResource, 6, clWater, 1, clFood, 10, clHill, 1, clRock, 6, clMetal, 6),
 	clFood);
 
 createFood(
 	[
 		[new SimpleObject(oBerryBush, 5, 7, 0, 4)]
 	],
 	[
 		3 * numPlayers
 	],
 	avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 10, clRock, 6, clMetal, 6),
 	clFood);
 
 Engine.SetProgress(90);
 
 createStragglerTrees(
 	[oDatePalm, oSDatePalm, oCarob, oFanPalm, oPoplar, oCypress],
 	avoidClasses(clForest, 1, clWater, 2, clPlayer, 8, clBaseResource, 6, clMetal, 6, clRock, 6, clHill, 1),
 	clForest,
 	stragglerTrees);
 
 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/english_channel.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/english_channel.js	(revision 20531)
+++ ps/trunk/binaries/data/mods/public/maps/random/english_channel.js	(revision 20532)
@@ -1,313 +1,310 @@
 Engine.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";
 
 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 landHeight = 3;
 var waterHeight = -4;
 
 var [playerIDs, playerX, playerZ] = playerPlacementRiver(Math.PI / 2, 0.6);
 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);
 }
 Engine.SetProgress(10);
 
 paintRiver({
 	"parallel": false,
 	"startX": 0,
 	"startZ": 0.5,
 	"endX": 1,
 	"endZ": 0.5,
 	"width": 0.25,
 	"fadeDist": 0.01,
 	"deviation": 0,
 	"waterHeight": waterHeight,
 	"landHeight": landHeight,
 	"meanderShort": 20,
 	"meanderLong": 0,
 	"waterFunc": (ix, iz, height, riverFraction) => {
 		placeTerrain(ix, iz, height < -1.5 ? tWater : tShore);
 	},
 	"landFunc": (ix, iz, shoreDist1, shoreDist2) => {
 		setHeight(ix, iz, landHeight + 0.1);
 	}
 });
 
 Engine.SetProgress(20);
 
 createTributaryRivers(
 	true,
 	randIntInclusive(9, scaleByMapSize(13, 21)),
 	scaleByMapSize(10, 20),
 	waterHeight,
 	[-6, -1.5],
 	Math.PI / 5,
 	clWater,
 	clShallow,
 	avoidClasses(clPlayer, 8, clBaseResource, 4));
 
 paintTerrainBasedOnHeight(-5, 1, 1, tWater);
 paintTerrainBasedOnHeight(1, landHeight, 1, tShore);
 paintTileClassBasedOnHeight(-6, 0.5, 1, clWater);
 Engine.SetProgress(25);
 
 createBumps(avoidClasses(clWater, 5, clPlayer, 20));
 Engine.SetProgress(30);
 
 createHills([tCliff, tCliff, tHill], avoidClasses(clPlayer, 20, clHill, 15, clWater, 5), clHill, scaleByMapSize(1, 4) * numPlayers);
 Engine.SetProgress(50);
 
 var [forestTrees, stragglerTrees] = getTreeCounts(500, 3000, 0.7);
 createForests(
  [tGrass, tGrassDForest, tGrassDForest, pForestD, pForestD],
  avoidClasses(clPlayer, 20, clForest, 17, clHill, 0, clWater, 6),
  clForest,
  forestTrees);
 Engine.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),
  scaleByMapSize(15, 45),
  clDirt);
 
 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),
  scaleByMapSize(15, 45),
  clDirt);
 Engine.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),
  clRock);
 
 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
 );
 Engine.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)
-);
+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),
+		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)
-);
+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),
 	clFood);
 
 createFood(
 	[
 		[new SimpleObject(oBerryBush, 5, 7, 0, 4)]
 	],
 	[
 		randIntInclusive(1, 4) * numPlayers + 2
 	],
 	avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 10),
 	clFood);
 
 createFood(
 	[
 		[new SimpleObject(oFish, 2, 3, 0, 2)]
 	],
 	[scaleByMapSize(3, 25) * numPlayers],
 	[avoidClasses(clFood, 6), stayClasses(clWater, 4)],
 	clFood);
 
 createStragglerTrees(
 	[oBeech, oPoplar, oApple],
 	avoidClasses(clWater, 1, clForest, 1, clHill, 1, clPlayer, 8, clMetal, 6, clRock, 6),
 	clForest,
 	stragglerTrees);
 
 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 20531)
+++ ps/trunk/binaries/data/mods/public/maps/random/extinct_volcano.js	(revision 20532)
@@ -1,505 +1,507 @@
 Engine.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 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 ccMountainSize = scaleByMapSize(15, 25);
 
 var [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 log("Creating CC mountains...");
 for (let i = 0; i < numPlayers; ++i)
 {
 	let ix = Math.round(fractionToTiles(playerX[i]));
 	let iz = Math.round(fractionToTiles(playerZ[i]));
 
 	// 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
 	createArea(
 		new ClumpPlacer(diskArea(scaleByMapSize(15, 25)), 0.95, 0.6, 10, ix, iz),
 		[
 			new LayeredPainter([tHillVeryDark, tHillMedium1], [ccMountainSize]),
 			new SmoothElevationPainter(ELEVATION_SET, ccMountainHeight, ccMountainSize),
 			paintClass(clPlayer)
 		],
 		null);
 }
 
 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]);
 
 	// Create the city patch
 	createArea(
 		new ClumpPlacer(diskArea(ccMountainSize / 3), 0.6, 0.3, 10, Math.round(fx), Math.round(fz)),
 		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(diskArea(ccMountainSize) / 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;
 		}
 	}
 }
 Engine.SetProgress(15);
 
 createVolcano(0.5, 0.5, clHill, tHillVeryDark, undefined, false, ELEVATION_SET);
 Engine.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)));
 Engine.SetProgress(25);
 
 createBumps(avoidClasses(clPlayer, 0, clHill, 0), scaleByMapSize(50, 300), 1, 10, 3, 0, scaleByMapSize(4, 10));
 paintTileClassBasedOnHeight(10, 100, 0, clBumps);
 Engine.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);
 Engine.SetProgress(35);
 
 log("Creating forests...");
 var [forestTrees, stragglerTrees] = getTreeCounts(1200, 3000, 0.7);
 var types = [
 	[[tGrassB, tGrassA, pForestD], [tGrassB, pForestD]],
 	[[tGrassB, tGrassA, pForestP], [tGrassB, pForestP]]
 ];
 var size = forestTrees / (scaleByMapSize(4, 12) * numPlayers);
 var num = Math.floor(size / types.length);
 for (let type of types)
 	createAreas(
 		new ClumpPlacer(forestTrees / num, 0.1, 0.1, 1),
 		[
 			new LayeredPainter(type, [2]),
 			paintClass(clForest)
 		],
 		avoidClasses(
 			clPlayer, 4,
 			clForest, 10,
 			clHill, 0,
 			clWater, 2),
 		num);
 Engine.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));
 Engine.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),
 	scaleByMapSize(3, 8),
 	clDirt);
 Engine.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);
 Engine.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);
 Engine.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);
 Engine.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);
 Engine.SetProgress(67);
 
 createDecoration(
 		[
-			[new SimpleObject(aGrassShort, 1, 2, 0, 1)],
+			[
+				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)
 		]);
 Engine.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
 		));
 Engine.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);
 Engine.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);
 Engine.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);
 Engine.SetProgress(85);
 
 createStragglerTrees(
 	[oTree, oTree2, oTree3, oTree4, oBush],
 	[
 		stayClasses(clGrass, 1),
 		avoidClasses(
 			clWater, 5,
 			clForest, 1,
 			clHill, 1,
 			clPlayer, 0,
 			clMetal, 1,
 			clRock, 1)
 	],
 	clForest,
 	stragglerTrees);
 
 Engine.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)
 	],
 	stragglerTrees);
 Engine.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));
 Engine.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 20531)
+++ ps/trunk/binaries/data/mods/public/maps/random/flood.js	(revision 20532)
@@ -1,386 +1,386 @@
 Engine.LoadLibrary("rmgen");
 Engine.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;
 
 var tHill = g_Terrains.hill;
 var tDirt = g_Terrains.dirt;
 if (currentBiome() == "temperate")
 {
 	tDirt = ["medit_shrubs_a", "grass_field"];
 	tHill = ["grass_field", "peat_temp"];
 }
 
 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;
 
 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 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 centerOfMap = mapSize / 2;
 
 const landHeight = 2;
 const waterHeight = getMapBaseHeight();
 const shoreRadius = 6;
 
 initTerrain(tWater);
 
 log("Creating the water...");
 createArea(
 	new ClumpPlacer(getMapArea(), 1, 1, 1, Math.round(fractionToTiles(0.5)), Math.round(fractionToTiles(0.5))),
 	[
 		new LayeredPainter([tWater, tWater, tShore], [1, 4]),
 		new SmoothElevationPainter(ELEVATION_SET, waterHeight, 2),
 		paintClass(clWater)
 	],
 	avoidClasses(clPlayer, 5));
 
 var [playerIDs, playerX, playerZ] = radialPlayerPlacement(0.38);
 
 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;
 
 	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;
 	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);
 }
 
 Engine.SetProgress(40);
 
 log("Creating central island...");
 createArea(
 	new ChainPlacer(
 		6,
 		Math.floor(scaleByMapSize(10, 15)),
 		Math.floor(scaleByMapSize(200, 300)),
 		1,
 		centerOfMap,
 		centerOfMap,
 		0,
 		[Math.floor(mapSize * 0.01)]),
 	[
 		new LayeredPainter([tShore, tMainTerrain], [shoreRadius, 100]),
 		new SmoothElevationPainter(ELEVATION_SET, landHeight, shoreRadius),
 		paintClass(clHill)
 	],
 	avoidClasses(clPlayer, 40));
 
 for (let m = 0; m < randIntInclusive(20, 34); ++m)
 {
 	let elevRand = randIntInclusive(6, 20);
 	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 elevRand = randIntInclusive(15, 29);
 	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)]);
 }
 
 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...");
 createObjectGroupsDeprecated(
 	new SimpleGroup([new SimpleObject(oFish, 2, 3, 0, 2)], true, clFood),
 	0,
 	avoidClasses(clHill, 10, clFood, 20),
 	10 * numPlayers,
 	60);
 
 var [forestTrees, stragglerTrees] = getTreeCounts(...rBiomeTreeCount(0.7));
 createForests(
 	[tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
 	[avoidClasses(clPlayer, 25, clForest, 10, clBaseResource, 3, clMetal, 6, clRock, 3, clMountain, 2), stayClasses(clHill, 6)],
 	clForest,
 	forestTrees);
 
 let types = [oTree1, oTree2, oTree4, oTree3];
 createStragglerTrees(
 	types,
 	[avoidClasses(clBaseResource, 2, clMetal, 6, clRock, 3, clMountain, 2, clPlayer, 25), stayClasses(clHill, 6)],
 	clForest,
 	stragglerTrees);
 Engine.SetProgress(65);
 
 log("Creating dirt patches...");
 var numb = currentBiome() == "savanna" ? 3 : 1;
 for (let size of [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)])
 	createAreas(
 		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));
 
 log("Painting shorelines...");
 paintTerrainBasedOnHeight(1, landHeight, 0, tMainTerrain);
 paintTerrainBasedOnHeight(waterHeight, 1, 3, tTier1Terrain);
 
 log("Creating grass patches...");
 for (let size of [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)])
 	createAreas(
 		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));
 
 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)],
 	clFood);
 
 Engine.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)],
 	clFood);
 
 Engine.SetProgress(85);
 
 createStragglerTrees(
 	types,
 	avoidClasses(clWater, 5, clForest, 7, clMountain, 1, clPlayer, 30, clMetal, 6, clRock, 3),
 	clForest,
 	stragglerTrees);
 
 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, 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(aGrassShort, 2, 15, 0, 1)],
+		[new SimpleObject(aGrass, 2, 10, 0, 1.8), new SimpleObject(aGrassShort, 3, 10, 1.2, 2.5)],
 		[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));
 
 log("Creating water forests...");
 var [forestTrees, stragglerTrees] = getTreeCounts(...rBiomeTreeCount(0.1));
 createForests(
 	[tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
 	avoidClasses(clPlayer, 30, clHill, 10, clFood, 5),
 	clForest,
 	forestTrees);
 
 log("Creating small grass tufts...");
 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));
 
 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 20531)
+++ ps/trunk/binaries/data/mods/public/maps/random/fortress.js	(revision 20532)
@@ -1,323 +1,322 @@
 Engine.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 oFoodTreasure = "gaia/special_treasure_food_bin";
 const oWoodTreasure = "gaia/special_treasure_wood";
 const oStoneTreasure = "gaia/special_treasure_stone";
 const oMetalTreasure = "gaia/special_treasure_metal";
 
 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++)
 {
 	log("Creating base for player " + playerIDs[i] + "...");
 	playerX[i] *= mapSize;
 	playerZ[i] *= mapSize;
 
 	for (let dist of [6, 8])
 	{
 		let ents = getStartingEntities(playerIDs[i]);
 
 		if (dist == 8)
 			ents = ents.filter(ent => ent.Template.indexOf("female") != -1 || ent.Template.indexOf("infantry") != -1);
 
 		placeStartingEntities(playerX[i], playerZ[i], playerIDs[i], ents, dist);
 	}
 
 	// 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(oFoodTreasure, 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(oWoodTreasure, 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(oMetalTreasure, 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(oStoneTreasure, 2,2, 0,2)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// Base texture
 	var civ = getCivCode(playerIDs[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, playerIDs[i]);
 }
 
 log("Creating lakes...");
 var numLakes = round(scaleByMapSize(1,4) * numPlayers);
 var waterAreas = createAreas(
 	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);
 
 Engine.SetProgress(15);
 
 log("Creating reeds...");
 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);
 
 Engine.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);
 Engine.SetProgress(30);
 
 createBumps(avoidClasses(clWater, 2, clPlayer, 5));
 Engine.SetProgress(35);
 
 log("Creating hills...");
 createHills([tCliff, tCliff, tHill], avoidClasses(clPlayer, 5, clWater, 5, clHill, 15), clHill, scaleByMapSize(1, 4) * numPlayers);
 Engine.SetProgress(40);
 
 log("Creating forests...");
 var [forestTrees, stragglerTrees] = getTreeCounts(500, 2500, 0.7);
 var types = [
 	[[tForestFloor, tGrass, pForestD], [tForestFloor, pForestD]],
 	[[tForestFloor, tGrass, pForestO], [tForestFloor, pForestO]],
 	[[tForestFloor, tGrass, pForestP], [tForestFloor, pForestP]]
 ];
 var size = forestTrees / (scaleByMapSize(3,6) * numPlayers);
 var num = floor(size / types.length);
 for (let type of types)
 	createAreas(
 		new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), forestTrees / num, 0.5),
 		[
 			new LayeredPainter(type, [2]),
 			paintClass(clForest)
 		],
 		avoidClasses(clPlayer, 5, clWater, 3, clForest, 15, clHill, 1),
 		num);
 Engine.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),
  scaleByMapSize(15, 45),
  clDirt);
 Engine.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),
  scaleByMapSize(15, 45),
  clDirt);
 Engine.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),
  clRock);
 Engine.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
 );
 Engine.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)
-);
+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),
+		scaleByMapSize(13, 200),
+		scaleByMapSize(13, 200),
+		scaleByMapSize(13, 200)
+	],
+	avoidClasses(clWater, 0, clForest, 0, clPlayer, 1, clHill, 0));
 Engine.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),
 	clFood);
 Engine.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),
 	clFood);
 
 Engine.SetProgress(90);
 
 createStragglerTrees(
 	[oOak, oBeech, oPine],
 	avoidClasses(clWater, 1, clForest, 1, clHill, 1, clPlayer, 1, clMetal, 6, clRock, 6),
 	clForest,
 	stragglerTrees);
 Engine.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 20531)
+++ ps/trunk/binaries/data/mods/public/maps/random/gear.js	(revision 20532)
@@ -1,382 +1,381 @@
 Engine.LoadLibrary("rmgen");
 Engine.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 = getMapArea();
 
 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, 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;
 	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);
 }
 
 Engine.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 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)
 {
 	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);
 }
 
 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.square(mapSize - 50) * 0.09, 1, 1, 10, center, center),
 	new SmoothElevationPainter(ELEVATION_SET, 4, 3),
 	null);
 
 log("Creating hill on the central island...");
 createArea(
 	new ClumpPlacer(diskArea(scaleByMapSize(6, 18)) * 7, 1, 1, 10, center, center),
 	new SmoothElevationPainter(ELEVATION_SET, 20, 8),
 	null);
 
 paintTerrainBasedOnHeight(-6, 1, 1, tWater);
 paintTerrainBasedOnHeight(1, 2, 1, tShore);
 paintTerrainBasedOnHeight(2, 21, 1, tMainTerrain);
 
 paintTileClassBasedOnHeight(-6, 0.5, 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);
 
 var [forestTrees, stragglerTrees] = getTreeCounts(...rBiomeTreeCount(1));
 createForests(
  [tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
  avoidClasses(clPlayer, 20, clForest, 17, clHill, 0, clWater, 2),
  clForest,
  forestTrees);
 
 Engine.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),
  scaleByMapSize(15, 45),
  clDirt);
 
 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),
  scaleByMapSize(15, 45),
  clDirt);
 Engine.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),
  clRock);
 
 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);
 
 Engine.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)
-);
+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),
+		planetm * scaleByMapSize(13, 200),
+		planetm * scaleByMapSize(13, 200),
+		planetm * scaleByMapSize(13, 200)
+	],
+	avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0));
 
 Engine.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),
 	clFood);
 
 createFood(
 	[
 		[new SimpleObject(oFruitBush, 5, 7, 0, 4)]
 	],
 	[
 		3 * numPlayers
 	],
 	avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 10),
 	clFood);
 
 createStragglerTrees(
 	[oTree1, oTree2, oTree4, oTree3],
 	avoidClasses(clWater, 5, clForest, 7, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6),
 	clForest,
 	stragglerTrees);
 
 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 20531)
+++ ps/trunk/binaries/data/mods/public/maps/random/guadalquivir_river.js	(revision 20532)
@@ -1,339 +1,337 @@
 Engine.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();
 
 var landHeight = 3;
 var shoreHeight = 2;
 var shallowHeight = -1.5;
 var waterHeight = -3;
 
 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, landHeight, 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);
 }
 Engine.SetProgress(20);
 
 paintRiver({
 	"parallel": true,
 	"constraint": stayClasses(clLand, 0),
 	"startX": 0.5,
 	"startZ": 0,
 	"endX": 0.5,
 	"endZ": 1,
 	"width": 0.07,
 	"fadeDist": 0.025,
 	"deviation": 0.0025,
 	"waterHeight": waterHeight,
 	"landHeight": shoreHeight,
 	"meanderShort": 12,
 	"meanderLong": 0,
 	"waterFunc": (ix, iz, height, z) => {
 		addToClass(ix, iz, clRiver);
 		placeTerrain(ix, iz, tWater);
 
 		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)]);
 
 var [forestTrees, stragglerTrees] = getTreeCounts(500, 3000, 0.7);
 createForests(
  [tGrass, tForestFloorP, tForestFloorC, pForestC, pForestP],
  [avoidClasses(clPlayer, 20, clForest, 17, clHill, 0, clRiver, 1), stayClasses(clLand, 7)],
  clForest,
  forestTrees);
 
 Engine.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)],
  scaleByMapSize(15, 45),
  clDirt);
 
 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)],
  scaleByMapSize(15, 45),
  clDirt);
 Engine.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)],
  clRock);
 
 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
 );
 Engine.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)]
-);
+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),
+		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)
-);
+createDecoration(
+	[
+		[new SimpleObject(aReeds, 1, 3, 0, 1)],
+		[new SimpleObject(aLillies, 1, 2, 0, 1)]
+	],
+	[
+		scaleByMapSize(800, 12800),
+		scaleByMapSize(800, 12800)
+	],
+	stayClasses(clShallow, 0));
 
 Engine.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)],
 	clFood);
 
 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)],
 	clFood);
 
 createFood(
 	[
 		[new SimpleObject(oFish, 2, 3, 0, 2)]
 	],
 	[
 		25 * numPlayers
 	],
 	avoidClasses(clLand, 2, clRiver, 1),
 	clFood);
 
 Engine.SetProgress(85);
 
 createStragglerTrees(
 	[oPoplar, oCarob, oApple],
 	[avoidClasses(clForest, 1, clHill, 1, clPlayer, 9, clMetal, 6, clRock, 6, clRiver, 1), stayClasses(clLand, 7)],
 	clForest,
 	stragglerTrees);
 
 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/lake.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/lake.js	(revision 20531)
+++ ps/trunk/binaries/data/mods/public/maps/random/lake.js	(revision 20532)
@@ -1,307 +1,306 @@
 Engine.LoadLibrary("rmgen");
 Engine.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();
 
 log("Preventing water in player territory...");
 for (let i = 0; i < numPlayers; ++i)
 	addCivicCenterAreaToClass(
 		Math.round(fractionToTiles(playerX[i])),
 		Math.round(fractionToTiles(playerZ[i])),
 		clPlayer);
 
 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);
 
 	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);
 }
 
 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...");
 createAreas(
 	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);
 
 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);
 
 var [forestTrees, stragglerTrees] = getTreeCounts(...rBiomeTreeCount(1));
 createForests(
  [tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
  avoidClasses(clPlayer, 20, clForest, 17, clHill, 0, clWater, 2),
  clForest,
  forestTrees);
 
 Engine.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),
  scaleByMapSize(15, 45),
  clDirt);
 
 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),
  scaleByMapSize(15, 45),
  clDirt);
 Engine.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),
  clRock);
 
 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
 );
 
 Engine.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)
-);
+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),
+		planetm * scaleByMapSize(13, 200),
+		planetm * scaleByMapSize(13, 200),
+		planetm * scaleByMapSize(13, 200)
+	],
+	avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0));
 
 Engine.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),
 	clFood);
 
 createFood(
 	[
 		[new SimpleObject(oFruitBush, 5, 7, 0, 4)]
 	],
 	[
 		3 * numPlayers
 	],
 	avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 10),
 	clFood);
 
 createFood(
 	[
 		[new SimpleObject(oFish, 2, 3, 0, 2)]
 	],
 	[
 		25 * numPlayers
 	],
 	[avoidClasses(clFood, 20), stayClasses(clWater, 6)],
 	clFood);
 
 Engine.SetProgress(85);
 
 createStragglerTrees(
 	[oTree1, oTree2, oTree4, oTree3],
 	avoidClasses(clWater, 5, clForest, 7, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6),
 	clForest,
 	stragglerTrees);
 
 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 20531)
+++ ps/trunk/binaries/data/mods/public/maps/random/mainland.js	(revision 20532)
@@ -1,245 +1,245 @@
 Engine.LoadLibrary("rmgen");
 Engine.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);
 }
 Engine.SetProgress(20);
 
 createBumps(avoidClasses(clPlayer, 20));
 
 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));
 
 var [forestTrees, stragglerTrees] = getTreeCounts(...rBiomeTreeCount(1));
 createForests(
  [tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
  avoidClasses(clPlayer, 20, clForest, 18, clHill, 0),
  clForest,
  forestTrees);
 
 Engine.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),
  scaleByMapSize(15, 45),
  clDirt);
 
 log("Creating grass patches...");
 createPatches(
  [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
  tTier4Terrain,
  avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12),
  scaleByMapSize(15, 45),
  clDirt);
 Engine.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),
  clRock);
 
 log("Creating metal mines...");
 createMines(
  [
   [new SimpleObject(oMetalLarge, 1,1, 0,4)]
  ],
  avoidClasses(clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 1),
  clMetal
 );
 
 Engine.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)
- ]
-);
+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),
+		planetm * scaleByMapSize(13, 200),
+		planetm * scaleByMapSize(13, 200),
+		planetm * scaleByMapSize(13, 200)
+	],
+	avoidClasses(clForest, 0, clPlayer, 0, clHill, 0));
 
 Engine.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),
 	clFood);
 
 Engine.SetProgress(75);
 
 createFood(
 	[
 		[new SimpleObject(oFruitBush, 5, 7, 0, 4)]
 	],
 	[
 		3 * numPlayers
 	],
 	avoidClasses(clForest, 0, clPlayer, 20, clHill, 1, clFood, 10),
 	clFood);
 
 Engine.SetProgress(85);
 
 createStragglerTrees(
 	[oTree1, oTree2, oTree4, oTree3],
 	avoidClasses(clForest, 8, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6),
 	clForest,
 	stragglerTrees);
 
 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 20531)
+++ ps/trunk/binaries/data/mods/public/maps/random/polar_sea.js	(revision 20532)
@@ -1,318 +1,320 @@
 Engine.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 oWoodTreasure = "gaia/special_treasure_wood";
 var oMarket = "skirmish/structures/default_market";
 
 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();
 
 var [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 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(oWoodTreasure, 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)),
 		oMarket,
 		id,
 		BUILDING_ORIENTATION);
 }
 Engine.SetProgress(30);
 
 log("Creating central 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)]),
 	[
 		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);
 Engine.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;
 
 	createAreas(
 		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);
 }
 Engine.SetProgress(50);
 
 createBumps(avoidClasses(clWater, 2, clPlayer, 20));
 Engine.SetProgress(60);
 
 log("Creating hills...");
 createHills(
 	[tPrimary, tPrimary, tSecondary],
 	avoidClasses(clPlayer, 20, clHill, 35),
 	clHill, scaleByMapSize(20, 240));
 Engine.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),
 	scaleByMapSize(15, 45),
 	clDirt);
 
 log("Creating glacier patches...");
 createPatches(
 	[scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
 	tSecondary,
 	avoidClasses(clWater, 3, clDirt, 5, clPlayer, 12),
 	scaleByMapSize(15, 45),
 	clDirt);
 Engine.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),
 	clRock);
 
 log("Creating metal mines...");
 createMines(
 	[
 		[new SimpleObject(oMetalLarge, 1,1, 0,4)]
 	],
 	avoidClasses(clWater, 3, clPlayer, 20, clMetal, 18, clRock, 5, clHill, 2),
 	clMetal);
 Engine.SetProgress(75);
 
 createDecoration(
 	[
-		[new SimpleObject(aRockMedium, 1,3, 0,1)],
 		[
-			new SimpleObject(aRockLarge, 1,2, 0,1),
-			new SimpleObject(aRockMedium, 1,3, 0,2)
+			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));
 
 createDecoration(
 	[
 		[new SimpleObject(aIceberg, 1, 1, 1, 1)]
 	],
 	[
 		scaleByMapSize(8, 131)
 	],
 	[stayClasses(clWater, 4), avoidClasses(clHill, 2)]);
 Engine.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),
 	clFood);
 
 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)],
 	clFood);
 
 createFood(
 	[
 		[new SimpleObject(oFish, 2, 3, 0, 2)]
 	],
 	[
 		100
 	],
 	[avoidClasses(clFood, 12, clHill, 5), stayClasses(clWater, 6)],
 	clFood);
 Engine.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);
 Engine.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/rivers.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/rivers.js	(revision 20531)
+++ ps/trunk/binaries/data/mods/public/maps/random/rivers.js	(revision 20532)
@@ -1,349 +1,346 @@
 Engine.LoadLibrary("rmgen");
 Engine.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 = getMapArea();
 
 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 waterHeight = -3;
 var shallowHeight = -1;
 
 initTerrain(tMainTerrain);
 
 log("Creating central lake...");
 var centralLake = [0.5, 0.5];
 createArea(
 	new ClumpPlacer(
 		mapArea / 100 * Math.pow(scaleByMapSize(1, 6), 1/8),
 		0.7,
 		0.1,
 		10,
 		fractionToTiles(centralLake[0]),
 		fractionToTiles(centralLake[1])),
 	[
 		new LayeredPainter([tShore, tWater, tWater, tWater], [1, 4, 2]),
 		new SmoothElevationPainter(ELEVATION_SET, waterHeight, 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
 	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(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);
 }
 Engine.SetProgress(20);
 
 log("Creating rivers between opponents...");
 var [riverX, riverZ] = distributePointsOnCircle(numPlayers, startAngle + Math.PI / numPlayers, 0.5, ...centralLake);
 for (let i = 0; i < numPlayers; ++i)
 {
 	if (areAllies(playerIDs[i], playerIDs[(i + 1) % numPlayers]))
 		continue;
 
 	let shallowLocation = randFloat(0.2, 0.7);
 	let shallowWidth = randFloat(0.12, 0.21);
 
 	paintRiver({
 		"parallel": true,
 		"startX": riverX[i],
 		"startZ": riverZ[i],
 		"endX": centralLake[0],
 		"endZ": centralLake[1],
 		"width": tilesToFraction(scaleByMapSize(10, 30)),
 		"fadeDist": tilesToFraction(5),
 		"deviation": 0,
 		"landHeight": getMapBaseHeight(),
 		"waterHeight": waterHeight,
 		"minHeight": waterHeight,
 		"meanderShort": tilesToFraction(scaleByMapSize(20, 60) * scaleByMapSize(35, 160)),
 		"meanderLong": 0,
 		"waterFunc": (ix, iz, height, riverFraction) => {
 
 			addToClass(ix, iz, clWater);
 
 			let isShallow = height < shallowHeight &&
 				riverFraction > shallowLocation &&
 				riverFraction < shallowLocation + shallowWidth;
 
 			let newHeight = isShallow ? shallowHeight : Math.max(height, waterHeight);
 
 			if (getHeight(ix, iz) < newHeight)
 				return;
 
 			setHeight(ix, iz, newHeight);
 			placeTerrain(ix, iz, height >= 0 ? tShore : tWater);
 
 			if (isShallow)
 				addToClass(ix, iz, clShallow);
 		}
 	});
 }
 Engine.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));
 
 var [forestTrees, stragglerTrees] = getTreeCounts(...rBiomeTreeCount(1));
 createForests(
  [tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
  avoidClasses(clPlayer, 20, clForest, 17, clHill, 0, clWater, 2),
  clForest,
  forestTrees);
 
 Engine.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),
  scaleByMapSize(15, 45),
  clDirt);
 
 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),
  scaleByMapSize(15, 45),
  clDirt);
 Engine.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),
  clRock);
 
 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
 );
 
 Engine.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)
-);
+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),
+		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)
-);
+createDecoration(
+	[
+		[new SimpleObject(aReeds, 1, 3, 0, 1)],
+		[new SimpleObject(aLillies, 1, 2, 0, 1)]
+	],
+	[
+		scaleByMapSize(800, 12800),
+		scaleByMapSize(800, 12800)
+	],
+	stayClasses(clShallow, 0));
 
 Engine.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),
 	clFood);
 
 createFood(
 	[
 		[new SimpleObject(oFruitBush, 5, 7, 0, 4)]
 	],
 	[
 		3 * numPlayers
 	],
 	avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 10),
 	clFood);
 
 createFood(
 	[
 		[new SimpleObject(oFish, 2, 3, 0, 2)]
 	],
 	[
 		25 * numPlayers
 	],
 	[avoidClasses(clFood, 20), stayClasses(clWater, 6)],
 	clFood);
 
 Engine.SetProgress(85);
 
 createStragglerTrees(
 	[oTree1, oTree2, oTree4, oTree3],
 	avoidClasses(clWater, 5, clForest, 7, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6),
 	clForest,
 	stragglerTrees);
 
 setWaterWaviness(3.0);
 setWaterType("lake");
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/schwarzwald.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/schwarzwald.js	(revision 20531)
+++ ps/trunk/binaries/data/mods/public/maps/random/schwarzwald.js	(revision 20532)
@@ -1,390 +1,389 @@
 Engine.LoadLibrary('rmgen');
 Engine.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 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
 
 ////////////////
 // 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);
 
 Engine.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]);
 
 Engine.SetProgress(50);
 
 //place water & open terrain textures and assign TileClasses
 log("Painting textures...");
 
 var betweenShallowAndShore = (heighLimits[3] + heighLimits[2]) / 2;
 createArea(
 	new HeightPlacer(Elevation_IncludeMin_IncludeMax, heighLimits[2], betweenShallowAndShore),
 	new LayeredPainter([terrainBase, terrainBaseBorder], [5]));
 
 paintTileClassBasedOnHeight(heighLimits[2], betweenShallowAndShore, 1, clOpen);
 
 createArea(
 	new HeightPlacer(Elevation_IncludeMin_IncludeMax, heightRange.min, heighLimits[2]),
 	new LayeredPainter([tWaterBorder, tWater], [2]));
 
 paintTileClassBasedOnHeight(heightRange.min,  heighLimits[2], 1, clWater);
 
 Engine.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 (Math.euclidDistance2D(x, z, targetX, targetZ) < pathSucsessRadius)
 				targetReached = true;
 
 			tries++;
 		}
 	}
 }
 
 Engine.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)
-);
+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),
+		scaleByMapSize(13, 200),
+		scaleByMapSize(13, 200),
+		scaleByMapSize(13, 200)
+	],
+	avoidClasses(clForest, 1, clPlayer, 0, clPath, 3, clWater, 3));
 
 Engine.SetProgress(80);
 
 log("Growing fish...");
 createFood(
 	[
 		[new SimpleObject(oFish, 2, 3, 0, 2)]
 	],
 	[
 		100 * numPlayers
 	],
 	[avoidClasses(clFood, 5), stayClasses(clWater, 4)],
 	clFood);
 
 Engine.SetProgress(85);
 
 log("Planting reeds...");
 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(1, 2) * 1000,
 		1000);
 
 Engine.SetProgress(90);
 
 log("Planting trees...");
 for (var x = 0; x < mapSize; x++)
 {
 	for (var z = 0;z < mapSize;z++)
 	{
 		if (!g_Map.validT(x, z))
 			continue;
 
 		// The 0.5 is a correction for the entities placed on the center of tiles
 		var radius = Math.euclidDistance2D(x + 0.5, z + 0.5, mapCenterX, mapCenterZ);
 		var minDistToSL = mapSize;
 		for (var i=0; i < numPlayers; i++)
 			minDistToSL = min(minDistToSL, Math.euclidDistance2D(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))
 			continue;
 
 		let border = tDensActual < randFloat(0, bushChance * maxTreeDensity);
 		createArea(
 			new ClumpPlacer(1, 1, 1, 1, x, z),
 			[
 				new TerrainPainter(border ? terrainWoodBorder : terrainWood),
 				paintClass(clForest)
 			],
 			border ?
 				avoidClasses(clPath, 1, clOpen, 2, clWater, 3) :
 				avoidClasses(clPath, 2, clOpen, 3, clWater, 4));
 	}
 }
 
 Engine.SetProgress(100);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/survivalofthefittest.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/survivalofthefittest.js	(revision 20531)
+++ ps/trunk/binaries/data/mods/public/maps/random/survivalofthefittest.js	(revision 20532)
@@ -1,203 +1,202 @@
 Engine.LoadLibrary("rmgen");
 Engine.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 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 mapArea = getMapArea();
 var mapCenter = getMapCenter();
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clDirt = createTileClass();
 var clBaseResource = createTileClass();
 var clLand = createTileClass();
 var clWomen = createTileClass();
 
 initTerrain(tMainTerrain);
 
 // Create the main treasure area in the middle of the map
 createArea(
 	new ClumpPlacer(mapArea * scaleByMapSize(0.065, 0.09), 0.7, 0.1, 10, mapCenter.x, mapCenter.y),
 	[
 		new LayeredPainter([tMainTerrain, tMainTerrain], [3]),
 		new SmoothElevationPainter(ELEVATION_SET, 3, 3),
 		paintClass(clLand)
 	]);
 Engine.SetProgress(10);
 
 var [playerIDs, playerX, playerZ, playerAngle, startAngle] = radialPlayerPlacement(0.3);
 var [halfwayX, halfwayZ] = distributePointsOnCircle(numPlayers, startAngle, fractionToTiles(0.375), mapCenter.x, mapCenter.y);
 var [attackerX, attackerZ] = distributePointsOnCircle(numPlayers, startAngle, fractionToTiles(0.45), mapCenter.x, mapCenter.y);
 var [passageX, passageZ] = distributePointsOnCircle(numPlayers, startAngle + Math.PI / numPlayers, fractionToTiles(0.5), mapCenter.x, mapCenter.y);
 
 log("Creating player bases and attacker points...");
 for (let  i = 0; i < numPlayers; ++i)
 {
 	let fx = fractionToTiles(playerX[i]);
 	let fz = fractionToTiles(playerZ[i]);
 
 	placeStartingEntities(fx, fz, playerIDs[i], getStartingEntities(playerIDs[i]).filter(ent =>
 		ent.Template.indexOf("civil_centre") != -1 || ent.Template.indexOf("infantry") != -1));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, scaleByMapSize(15, 25));
 
 	log("Creating passage separating players...");
 	createArea(
 		new PathPlacer(mapCenter.x, mapCenter.y, passageX[i], passageZ[i], scaleByMapSize(14, 24), 0.4, scaleByMapSize(3, 9), 0.2, 0.05),
 		[
 			new LayeredPainter([tMainTerrain, tMainTerrain], [1]),
 			new SmoothElevationPainter(ELEVATION_SET, 3, 4)
 		]);
 
 	log("Placing treasure seeker woman...");
 	let femaleLocation = getTIPIADBON([fx, fz], [mapCenter.x, mapCenter.y], [-3 , 3.5], 1, 3);
 	placeObject(femaleLocation[0], femaleLocation[1], oTreasureSeeker, playerIDs[i], playerAngle[i] + Math.PI);
 	addToClass(Math.floor(femaleLocation[0]), Math.floor(femaleLocation[1]), clWomen);
 
 	log("Placing attacker spawn point....");
 	placeObject(attackerX[i], attackerZ[i], aWaypointFlag, 0, Math.PI / 2);
 	placeObject(attackerX[i], attackerZ[i], triggerPointAttacker, playerIDs[i], Math.PI / 2);
 
 	log("Preventing mountains in the area between player and attackers...");
 	addCivicCenterAreaToClass(Math.round(fx), Math.round(fz), clPlayer);
 	addToClass(Math.round(attackerX[i]), Math.round(attackerZ[i]), clPlayer);
 	addToClass(Math.round(halfwayX[i]), Math.round(halfwayZ[i]), clPlayer);
 }
 Engine.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
 	);
 Engine.SetProgress(25);
 
 createBumps(stayClasses(clLand, 5));
 
 var [forestTrees, stragglerTrees] = getTreeCounts(...rBiomeTreeCount(1));
 createForests(
 	[tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
 	[avoidClasses(clPlayer, 20, clForest, 5, clHill, 0, clBaseResource,2, clWomen, 5), stayClasses(clLand, 4)],
 	clForest,
 	forestTrees);
 Engine.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);
 Engine.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);
 
 Engine.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)],
 	scaleByMapSize(15, 45),
 	clDirt);
 
 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)],
 	scaleByMapSize(15, 45),
 	clDirt);
 
 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(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),
 		planetm * scaleByMapSize(13, 200),
 		planetm * scaleByMapSize(13, 200),
 		planetm * scaleByMapSize(13, 200)
 	],
-	[avoidClasses(clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 5)]
-);
+	[avoidClasses(clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 5)]);
 
 createStragglerTrees(
 	[oTree1, oTree2, oTree4, oTree3],
 	[avoidClasses(clForest, 7, clHill, 1, clPlayer, 9), stayClasses(clLand, 7)],
 	clForest,
 	stragglerTrees);
 
 ExportMap();