Index: ps/trunk/binaries/data/mods/public/maps/random/corinthian_isthmus.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/corinthian_isthmus.js	(revision 20263)
+++ ps/trunk/binaries/data/mods/public/maps/random/corinthian_isthmus.js	(revision 20264)
@@ -1,334 +1,324 @@
 RMS.LoadLibrary("rmgen");
 
 TILE_CENTERED_HEIGHT_MAP = true;
 
 const tCity = "medit_city_pavement";
 const tCityPlaza = "medit_city_pavement";
 const tHill = ["medit_grass_shrubs", "medit_rocks_grass_shrubs", "medit_rocks_shrubs", "medit_rocks_grass", "medit_shrubs"];
 const tMainDirt = "medit_dirt";
 const tCliff = "medit_cliff_aegean";
 const tForestFloor = "medit_grass_shrubs";
 const tGrass = ["medit_grass_field", "medit_grass_field_a"];
 const tGrassSand50 = "medit_grass_field_a";
 const tGrassSand25 = "medit_grass_field_b";
 const tDirt = "medit_dirt_b";
 const tDirt2 = "medit_rocks_grass";
 const tDirt3 = "medit_rocks_shrubs";
 const tDirtCracks = "medit_dirt_c";
 const tShore = "medit_sand";
 const tWater = "medit_sand_wet";
 
 const oBerryBush = "gaia/flora_bush_berry";
 const oDeer = "gaia/fauna_deer";
 const oFish = "gaia/fauna_fish";
 const oSheep = "gaia/fauna_sheep";
 const oGoat = "gaia/fauna_goat";
 const oStoneLarge = "gaia/geology_stonemine_medit_quarry";
 const oStoneSmall = "gaia/geology_stone_mediterranean";
 const oMetalLarge = "gaia/geology_metal_mediterranean_slabs";
 const oDatePalm = "gaia/flora_tree_cretan_date_palm_short";
 const oSDatePalm = "gaia/flora_tree_cretan_date_palm_tall";
 const oCarob = "gaia/flora_tree_carob";
 const oFanPalm = "gaia/flora_tree_medit_fan_palm";
 const oPoplar = "gaia/flora_tree_poplar_lombardy";
 const oCypress = "gaia/flora_tree_cypress";
 
 const aBush1 = "actor|props/flora/bush_medit_sm.xml";
 const aBush2 = "actor|props/flora/bush_medit_me.xml";
 const aBush3 = "actor|props/flora/bush_medit_la.xml";
 const aBush4 = "actor|props/flora/bush_medit_me.xml";
 const aBushes = [aBush1, aBush2, aBush3, aBush4];
 const aDecorativeRock = "actor|geology/stone_granite_med.xml";
 
 // terrain + entity (for painting)
 const pForest = [tForestFloor, tForestFloor + TERRAIN_SEPARATOR + oCarob, tForestFloor + TERRAIN_SEPARATOR + oDatePalm, tForestFloor + TERRAIN_SEPARATOR + oSDatePalm, tForestFloor];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 const mapArea = mapSize*mapSize;
 
 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 clSettlement = createTileClass();
 var clGrass = createTileClass();
 var clHill = createTileClass();
 
 log("Creating the main river");
 var placer = new PathPlacer(fractionToTiles(0.5 + cos(3 * PI / 4)), fractionToTiles(0.5 + sin(3 * PI / 4)), fractionToTiles(0.5 + cos(- PI / 4)), fractionToTiles(0.5 + sin(- PI / 4)), scaleByMapSize(15,70), 0.2, 3*(scaleByMapSize(5,15)), 0.04, 0.01);
 var terrainPainter = new LayeredPainter(
 	[tShore, tWater, tWater],		// terrains
 	[1, 3]								// widths
 );
 var elevationPainter = new SmoothElevationPainter(
 	ELEVATION_SET,			// type
 	-4,				// elevation
 	4				// blend radius
 );
 createArea(placer, [terrainPainter, elevationPainter], avoidClasses(clPlayer, 4));
 
 placer = new ClumpPlacer(floor(PI*scaleByMapSize(15,70)*scaleByMapSize(15,70)/4), 0.95, 0.6, 10, fractionToTiles(0.5 + cos(3 * PI / 4))+3, fractionToTiles(0.5 + sin(3 * PI / 4))-3);
 var painter = new LayeredPainter([tWater, tWater], [1]);
 var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -4, 4);
 createArea(placer, [painter, elevationPainter], avoidClasses(clPlayer, 8));
 
 placer = new ClumpPlacer(floor(PI*scaleByMapSize(15,70)*scaleByMapSize(15,70)/4), 0.95, 0.6, 10, fractionToTiles(0.5 + cos(- PI / 4))-3, fractionToTiles(0.5 + sin(- PI / 4))+3);
 var painter = new LayeredPainter([tWater, tWater], [1]);
 var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -4, 4);
 createArea(placer, [painter, elevationPainter], avoidClasses(clPlayer, 8));
 
-for (var ix = 0; ix < mapSize; ix++)
-{
-	for (var iz = 0; iz < mapSize; iz++)
-	{
-		if ((ix + iz < scaleByMapSize(6,30) + mapSize)&&(ix + iz > - scaleByMapSize(6,30) + mapSize))
-			if ((ix - iz < mapSize / 2)||(ix - iz > mapSize / 2))
-				setHeight(ix, iz, -4);
-	}
-}
-
 var placer = new PathPlacer(fractionToTiles(0.5 + cos(5 * PI / 4)), fractionToTiles(0.5 + sin(5 * PI / 4)), fractionToTiles(0.5 + cos( PI / 4)), fractionToTiles(0.5 + sin( PI / 4)), scaleByMapSize(10,30), 0.5, 3*(scaleByMapSize(1,4)), 0.1, 0.01);
 var terrainPainter = new LayeredPainter(
 	[tShore, tGrass],		// terrains
 	[2]								// widths
 );
 var elevationPainter = new SmoothElevationPainter(
 	ELEVATION_SET,			// type
 	3,				// elevation
 	4				// blend radius
 );
 createArea(placer, [terrainPainter, elevationPainter], null);
 
 paintTerrainBasedOnHeight(-6, 1, 1, tWater);
 paintTerrainBasedOnHeight(1, 2, 1, tShore);
 paintTerrainBasedOnHeight(2, 5, 1, tGrass);
 
 paintTileClassBasedOnHeight(-6, 0.5, 1, clWater);
 
 var playerIDs = primeSortAllPlayers();
 var playerPos = placePlayersRiver();
 
 var playerX = [];
 var playerZ = [];
 
 for (var i = 0; i < numPlayers; i++)
 {
 	playerZ[i] = Math.sqrt(0.5)*(0.6*(i%2) - 0.8 + playerPos[i]) + 0.5;
 	playerX[i] = Math.sqrt(0.5)*(0.6*(i%2) + 0.2 - playerPos[i]) + 0.5;
 }
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = floor(fx);
 	var iz = floor(fz);
 	addToClass(ix, iz, clPlayer);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	var placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tCityPlaza, tCity], [1]);
 	createArea(placer, painter, null);
 
 	placeCivDefaultEntities(fx, fz, id, { 'iberWall': 'towers' });
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oBerryBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var num = 2;
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(11, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oCarob, num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aBush1, clBaseResource, radius);
 }
 
 RMS.SetProgress(40);
 
 createBumps(avoidClasses(clWater, 2, clPlayer, 20));
 
 createForests(
  [tForestFloor, tForestFloor, tForestFloor, pForest, pForest],
  avoidClasses(clPlayer, 20, clForest, 17, clWater, 2, clBaseResource, 3),
  clForest
 );
 
 RMS.SetProgress(50);
 
 if (randBool())
 	createHills([tGrass, tCliff, tHill], avoidClasses(clPlayer, 20, clForest, 1, clHill, 15, clWater, 3), clHill, scaleByMapSize(3, 15));
 else
 	createMountains(tCliff, avoidClasses(clPlayer, 20, clForest, 1, clHill, 15, clWater, 3), clHill, scaleByMapSize(3, 15));
 
 log("Creating grass patches...");
 createLayeredPatches(
  [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
  [[tGrass,tGrassSand50],[tGrassSand50,tGrassSand25], [tGrassSand25,tGrass]],
  [1,1],
  avoidClasses(clForest, 0, clGrass, 2, clPlayer, 10, clWater, 2, clDirt, 2, clHill, 1)
 );
 
 RMS.SetProgress(55);
 
 log("Creating dirt patches...");
 createLayeredPatches(
  [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
  [tDirt3, tDirt2,[tDirt,tMainDirt], [tDirtCracks,tMainDirt]],
  [1,1,1],
  avoidClasses(clForest, 0, clDirt, 2, clPlayer, 10, clWater, 2, clGrass, 2, clHill, 1)
 );
 
 RMS.SetProgress(60);
 
 log("Creating stone mines...");
 createMines(
  [
   [new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)],
   [new SimpleObject(oStoneSmall, 2,5, 1,3)]
  ],
  avoidClasses(clForest, 1, clPlayer, 20, clRock, 10, clWater, 1, clHill, 1)
 );
 
 log("Creating metal mines...");
 createMines(
  [
   [new SimpleObject(oMetalLarge, 1,1, 0,4)]
  ],
  avoidClasses(clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clWater, 1, clHill, 1),
  clMetal
 );
 
 RMS.SetProgress(65);
 
 createDecoration
 (
  [[new SimpleObject(aDecorativeRock, 1,3, 0,1)],
   [new SimpleObject(aBush2, 1,2, 0,1), new SimpleObject(aBush1, 1,3, 0,2), new SimpleObject(aBush4, 1,2, 0,1), new SimpleObject(aBush3, 1,3, 0,2)]
  ],
  [
   scaleByMapSize(16, 262),
   scaleByMapSize(40, 360)
  ],
  avoidClasses(clWater, 2, clForest, 0, clPlayer, 0, clHill, 1)
 );
 
 RMS.SetProgress(70);
 
 createFood
 (
  [
   [new SimpleObject(oFish, 2,3, 0,2)]
  ],
  [
   3*scaleByMapSize(5,20)
  ],
  [avoidClasses(clFood, 10), stayClasses(clWater, 5)]
 );
 
 createFood
 (
  [
   [new SimpleObject(oSheep, 5,7, 0,4)],
   [new SimpleObject(oGoat, 2,4, 0,3)],
   [new SimpleObject(oDeer, 2,4, 0,2)]
  ],
  [
   scaleByMapSize(5,20),
   scaleByMapSize(5,20),
   scaleByMapSize(5,20)
  ],
  avoidClasses(clForest, 0, clPlayer, 8, clWater, 1, clFood, 10, clHill, 1)
 );
 
 createFood
 (
  [
   [new SimpleObject(oBerryBush, 5,7, 0,4)]
  ],
  [
   3 * numPlayers
  ],
  avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 10)
 );
 
 RMS.SetProgress(90);
 
 log("Creating straggler trees...");
 var types = [oDatePalm, oSDatePalm, oCarob, oFanPalm, oPoplar, oCypress];	// some variation
 createStragglerTrees(types, avoidClasses(clForest, 1, clWater, 2, clPlayer, 8, clMetal, 6, clHill, 1));
 
 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/river_archipelago.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/river_archipelago.js	(revision 20263)
+++ ps/trunk/binaries/data/mods/public/maps/random/river_archipelago.js	(revision 20264)
@@ -1,555 +1,551 @@
 RMS.LoadLibrary("rmgen");
 
 const tGrass = ["tropic_grass_c", "tropic_grass_c", "tropic_grass_c", "tropic_grass_c", "tropic_grass_plants", "tropic_plants", "tropic_plants_b"];
 const tGrassA = "tropic_plants_c";
 const tGrassB = "tropic_plants_c";
 const tGrassC = "tropic_grass_c";
 const tForestFloor = "tropic_grass_plants";
 const tCliff = ["tropic_cliff_a", "tropic_cliff_a", "tropic_cliff_a", "tropic_cliff_a_plants"];
 const tPlants = "tropic_plants";
 const tRoad = "tropic_citytile_a";
 const tRoadWild = "tropic_citytile_plants";
 const tShoreBlend = "tropic_beach_dry_plants";
 const tShore = "tropic_beach_dry";
 const tWater = "tropic_beach_wet";
 
 const oTree = "gaia/flora_tree_toona";
 const oPalm1 = "gaia/flora_tree_palm_tropic";
 const oPalm2 = "gaia/flora_tree_palm_tropical";
 const oStoneLarge = "gaia/geology_stonemine_tropic_quarry";
 const oStoneSmall = "gaia/geology_stone_tropic_a";
 const oMetalLarge = "gaia/geology_metal_tropic_slabs";
 const oFish = "gaia/fauna_fish";
 const oDeer = "gaia/fauna_deer";
 const oTiger = "gaia/fauna_tiger";
 const oBoar = "gaia/fauna_boar";
 const oPeacock = "gaia/fauna_peacock";
 const oBush = "gaia/flora_bush_berry";
 const oSpearman = "units/maur_infantry_spearman_b";
 const oArcher = "units/maur_infantry_archer_b";
 const oArcherElephant = "units/maur_elephant_archer_b";
 
 const aRockLarge = "actor|geology/stone_granite_large.xml";
 const aRockMedium = "actor|geology/stone_granite_med.xml";
 const aBush1 = "actor|props/flora/plant_tropic_a.xml";
 const aBush2 = "actor|props/flora/plant_lg.xml";
 const aBush3 = "actor|props/flora/plant_tropic_large.xml";
 
 const pForestD = [tForestFloor + TERRAIN_SEPARATOR + oTree, tForestFloor];
 const pForestP1 = [tForestFloor + TERRAIN_SEPARATOR + oPalm1, tForestFloor];
 const pForestP2 = [tForestFloor + TERRAIN_SEPARATOR + oPalm2, tForestFloor];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 
 var clPlayer = createTileClass();
 var clPlayerTerritory = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clGaia = createTileClass();
 var clStrip = [];
 
-log("Creating terrain...");
-for (let ix = 0; ix < mapSize; ++ix)
-	for (let iz = 0; iz < mapSize; ++iz)
-		setHeight(ix, iz, -8);
 var connectPlayers = randBool();
 
 // Map layout
 var stripWidthsLeft = connectPlayers ?
 	[[0.03, 0.09], [0.14, 0.25], [0.36, 0.46]] : 
 	[[0, 0.06], [0.12, 0.23], [0.33, 0.43]];
 
 var playerPosLeft = (stripWidthsLeft[2][0] + stripWidthsLeft[2][1]) / 2;
 
 // Mirror
 var stripWidthsRight = clone(stripWidthsLeft);
 stripWidthsRight.reverse();
 stripWidthsRight = stripWidthsRight.map(strip => [1 - strip[1], 1 - strip[0]]);
 
 var stripWidths = stripWidthsLeft.concat(stripWidthsRight);
 var playerPos = [playerPosLeft, 1 - playerPosLeft];
 
 for (let i = 0; i < stripWidths.length; ++i)
 {
 	clStrip[i] = createTileClass();
 
 	let isPlayerStrip = i == 2 || i == 3;
 	for (let j = 0; j < scaleByMapSize(20, 100); ++j)
 		createArea(
 			new ChainPlacer(
 				1,
 				Math.floor(scaleByMapSize(3, connectPlayers && isPlayerStrip ? 8 : 7)),
 				Math.floor(scaleByMapSize(30, 60)),
 				1,
 				Math.floor(randFloat(...stripWidths[i]) * mapSize),
 				Math.floor(randFloat(0, 1) * mapSize)),
 			[
 				new LayeredPainter([tGrass, tGrass], [2]),
 				new SmoothElevationPainter(ELEVATION_SET, 3, 3),
 				paintClass(clStrip[i])
 			],
 			null);
 }
 RMS.SetProgress(20);
 
 var playerIDs = sortAllPlayers();
 
 // Either left vs right or top vs bottom
 var leftVSRight = randBool();
 
 for (let i = 0; i < numPlayers; ++i)
 {
 	let playerX;
 	let playerZ;
 
 	if (leftVSRight)
 	{
 		let left = i < numPlayers / 2;
 		playerX = playerPos[left ? 0 : 1];
 		playerZ = 2 * (left ? i + 1 : numPlayers - i - 0.5) / (numPlayers + 1 + numPlayers % 2);
 	}
 	else
 	{
 		playerX = playerPos[i % 2];
 		playerZ = (i + 1) / (numPlayers + 1);
 	}
 
 	log("Creating base for player " + playerIDs[i] + "...");
 	let radius = scaleByMapSize(12, 20);
 
 	let fx = fractionToTiles(playerX);
 	let fz = fractionToTiles(playerZ);
 	let ix = Math.round(fx);
 	let iz = Math.round(fz);
 
 	addCivicCenterAreaToClass(ix, iz, clPlayer);
 
 	// Create the main island
 	createArea(
 		new ChainPlacer(1, 6, 40, 1, ix, iz, 0, [Math.floor(radius)]),
 		[
 			new LayeredPainter([tGrass, tGrass, tGrass], [1, 4]),
 			new SmoothElevationPainter(ELEVATION_SET, 3, 4),
 			paintClass(clPlayerTerritory)
 		], null);
 
 	// Create the city patch
 	let cityRadius = radius / 3;
 	createArea(
 		new ClumpPlacer(PI * cityRadius * cityRadius, 0.6, 0.3, 10, ix, iz),
 		new LayeredPainter([tRoadWild, tRoad], [1]),
 		null);
 
 	placeCivDefaultEntities(fx, fz, playerIDs[i],  { 'iberWall': 'towers' });
 
 	placeDefaultChicken(fx, fz, clBaseResource, undefined, oPeacock);
 
 	// Create berry bushes
 	let angle = randFloat(0, 2 * PI);
 	let dist = 12;
 	createObjectGroup(
 		new SimpleGroup(
 			[new SimpleObject(oBush, 5, 5, 0, 3)],
 			true,
 			clBaseResource,
 			Math.round(fx + dist * Math.cos(angle)),
 			Math.round(fz + dist * Math.sin(angle))),
 		0);
 
 	// Create metal mine
 	angle += randFloat(PI/8, PI/4);
 	createObjectGroup(
 		new SimpleGroup(
 			[new SimpleObject(oMetalLarge, 1, 1, 0, 0)],
 			true,
 			clBaseResource,
 			Math.round(fx + dist * Math.cos(angle)),
 			Math.round(fz + dist * Math.sin(angle))),
 		0);
 
 	// Create stone mines
 	angle += randFloat(PI/8, PI/4);
 	createObjectGroup(
 		new SimpleGroup(
 			[new SimpleObject(oStoneLarge, 1, 1, 0, 2)],
 			true,
 			clBaseResource,
 			Math.round(fx + dist * Math.cos(angle)),
 			Math.round(fz + dist * Math.sin(angle))),
 		0);
 
 	// Create starting trees
 	let num = 40;
 	let tAngle = randFloat(-PI/3, 4*PI/3);
 	let tDist = randFloat(12, 13);
 	createObjectGroup(
 		new SimpleGroup(
 			[new SimpleObject(oTree, num, num, 0, 3)],
 			false,
 			clBaseResource,
 			Math.round(fx + tDist * Math.cos(tAngle)),
 			Math.round(fz + tDist * Math.sin(tAngle))),
 		0,
 		avoidClasses(clBaseResource, 2));
 }
 RMS.SetProgress(35);
 
 log("Creating gaia...");
 for (let i = 0; i < 2; ++i)
 	for (let j = 0; j < scaleByMapSize(1, 8); ++j)
 		createObjectGroupsDeprecated(
 			new SimpleGroup(
 				[
 					new SimpleObject(oSpearman, 8, 12, 2, 3),
 					new SimpleObject(oArcher, 8, 12, 2, 3),
 					new SimpleObject(oArcherElephant, 2, 3, 4, 5)
 				],
 				true,
 				clGaia),
 			0,
 			[
 				avoidClasses(
 					clWater, 2,
 					clForest, 1,
 					clPlayerTerritory, 0,
 					clHill, 1,
 					clGaia, 15),
 				stayClasses(clStrip[i == 0 ? 0 : stripWidths.length - 1], 1)
 			],
 			scaleByMapSize(5, 10),
 			50);
 
 paintTerrainBasedOnHeight(-10, 0, 1, tWater);
 paintTileClassBasedOnHeight(-10, 0, 1, clWater);
 paintTerrainBasedOnHeight(1, 2.8, 1, tShoreBlend);
 paintTerrainBasedOnHeight(0, 1, 1, tShore);
 RMS.SetProgress(40);
 
 log("Creating hills...");
 createAreas(
 	new ChainPlacer(1, Math.floor(scaleByMapSize(4, 6)), Math.floor(scaleByMapSize(16, 40)), 0.1),
 	[
 		new LayeredPainter([tCliff, tGrass], [3]),
 		new SmoothElevationPainter(ELEVATION_SET, 25, 3),
 		paintClass(clHill)
 	],
 	[
 		avoidClasses(
 			clPlayerTerritory, 0,
 			clHill, 5,
 			clGaia, 1,
 			clWater, 2)
 	],
 	scaleByMapSize(1, 5));
 
 log("Creating bumps...");
 createBumps(avoidClasses(clPlayer, 8, clWater, 2), scaleByMapSize(20, 150), 2, 8, 4, 1, 4);
 RMS.SetProgress(50);
 
 log("Creating forests...");
 var P_FOREST = 0.7;
 var totalTrees = scaleByMapSize(1000, 4000);
 var numForest = totalTrees * P_FOREST;
 var numStragglers = totalTrees * (1.0 - P_FOREST);
 
 var types = [
 	[[tGrass, tGrass, tGrass, tGrass, pForestD], [tGrass, tGrass, tGrass, pForestD]],
 	[[tGrass, tGrass, tGrass, tGrass, pForestP1], [tGrass, tGrass, tGrass, pForestP1]],
 	[[tGrass, tGrass, tGrass, tGrass, pForestP2], [tGrass, tGrass, tGrass, pForestP2]]
 ];
 var size = numForest / (scaleByMapSize(3, 6) * numPlayers);
 var num = Math.floor(size / types.length);
 for (let type of types)
 	createAreas(
 		new ChainPlacer(
 			1,
 			Math.floor(scaleByMapSize(3, 5)),
 			numForest / (num * Math.floor(scaleByMapSize(2, 4))),
 			0.5),
 		[
 			new LayeredPainter(type, [2]),
 			paintClass(clForest)
 		],
 		avoidClasses(
 			clPlayer, 12,
 			clForest, 6,
 			clHill, 0,
 			clGaia, 1,
 			clWater, 2),
 		num);
 
 log("Creating straggler trees...");
 var types = [oTree, oPalm1, oPalm2];
 var num = Math.floor(numStragglers / types.length);
 for (let type of types)
 	createObjectGroupsDeprecated(
 		new SimpleGroup([new SimpleObject(type, 1, 1, 0, 3)], true, clForest),
 		0,
 		avoidClasses(
 			clWater, 5,
 			clForest, 1,
 			clHill, 1,
 			clPlayer, 8,
 			clBaseResource, 4,
 			clGaia, 1,
 			clMetal, 4,
 			clRock, 4),
 		num);
 RMS.SetProgress(60);
 
 log("Creating grass patches...");
 var sizes = [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)];
 for (let i = 0; i < sizes.length; ++i)
 	createAreas(
 		new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), sizes[i], 0.5),
 		[
 			new LayeredPainter([tGrassC, tGrassA, tGrassB], [2, 1]),
 			paintClass(clDirt)
 		],
 		avoidClasses(
 			clWater, 8,
 			clForest, 0,
 			clHill, 0,
 			clGaia, 1,
 			clPlayerTerritory, 0,
 			clDirt, 16),
 		scaleByMapSize(20, 80));
 
 log("Creating dirt patches...");
 var sizes = [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)];
 for (let i = 0; i < sizes.length; ++i)
 	createAreas(
 		new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), sizes[i], 0.5),
 		[
 			new LayeredPainter([tPlants, tPlants], [1]),
 			paintClass(clDirt)
 		],
 		avoidClasses(
 			clWater, 8,
 			clForest, 0,
 			clHill, 0,
 			clGaia, 1,
 			clPlayerTerritory, 0,
 			clDirt, 16),
 		scaleByMapSize(20, 80));
 
 log("Creating stone mines...");
 createObjectGroupsDeprecated(
 	new SimpleGroup(
 		[
 			new SimpleObject(oStoneSmall, 0, 2, 0, 4),
 			new SimpleObject(oStoneLarge, 1, 1, 0, 4)
 		],
 		true,
 		clRock),
 	0,
 	avoidClasses(
 		clWater, 3,
 		clForest, 1,
 		clPlayerTerritory, 0,
 		clGaia, 1,
 		clRock, 10,
 		clHill, 1),
 		9 * scaleByMapSize(1, 4),
 		100);
 
 log("Creating small stone mines...");
 createObjectGroupsDeprecated(
 	new SimpleGroup([new SimpleObject(oStoneSmall, 2, 5, 1, 3)], true, clRock),
 	0,
 	avoidClasses(
 		clWater, 4,
 		clForest, 1,
 		clPlayerTerritory, 0,
 		clGaia, 1,
 		clRock, 10,
 		clHill, 1),
 		9 * scaleByMapSize(1, 4),
 	100);
 
 log("Creating metal mines...");
 createObjectGroupsDeprecated(
 	new SimpleGroup([new SimpleObject(oMetalLarge, 1, 1, 0, 4)], true, clMetal),
 	0,
 	avoidClasses(
 		clWater, 4,
 		clForest, 1,
 		clPlayerTerritory, 0,
 		clGaia, 1,
 		clMetal, 10,
 		clRock, 5,
 		clHill, 1),
 	9 * scaleByMapSize(1, 4),
 	100);
 
 log("Creating small decorative rocks...");
 createObjectGroupsDeprecated(
 	new SimpleGroup([new SimpleObject(aRockMedium, 1, 3, 0, 1)], true),
 	0,
 	avoidClasses(
 		clWater, 2,
 		clForest, 1,
 		clGaia, 1,
 		clPlayer, 8,
 		clBaseResource, 4,
 		clHill, 0),
 	3 * scaleByMapSize(16, 262),
 	50);
 
 log("Creating large decorative rocks...");
 createObjectGroupsDeprecated(
 	new SimpleGroup([
 			new SimpleObject(aRockLarge, 1, 2, 0, 1),
 			new SimpleObject(aRockMedium, 1, 3, 0, 2)
 		],
 		true),
 	0,
 	avoidClasses(
 		clWater, 2,
 		clForest, 1,
 		clGaia, 1,
 		clPlayer, 8,
 		clBaseResource, 4,
 		clHill, 0),
 	3 * scaleByMapSize(8, 131),
 	50);
 
 log("Creating small grass tufts...");
 createObjectGroupsDeprecated(
 	new SimpleGroup([new SimpleObject(aBush1, 1, 2, 0, 1, -PI/8, PI/8)]),
 	0,
 	avoidClasses(
 		clWater, 4,
 		clHill, 2,
 		clPlayer, 8,
 		clGaia, 1,
 		clBaseResource, 4,
 		clDirt, 0),
 	8 * scaleByMapSize(13, 200));
 RMS.SetProgress(70);
 
 log("Creating large grass tufts...");
 	createObjectGroupsDeprecated(
 		new SimpleGroup([
 			new SimpleObject(aBush2, 2, 4, 0, 1.8, -PI/8, PI/8),
 			new SimpleObject(aBush1, 3, 6, 1.2, 2.5, -PI/8, PI/8)
 		]),
 		0,
 		avoidClasses(
 			clWater, 4,
 			clHill, 2,
 			clGaia, 1,
 			clPlayer, 8,
 			clBaseResource, 4,
 			clDirt, 1,
 			clForest, 0),
 		8 * scaleByMapSize(13, 200));
 RMS.SetProgress(85);
 
 log("Creating bushes...");
 	createObjectGroupsDeprecated(
 		new SimpleGroup([
 			new SimpleObject(aBush3, 1, 2, 0, 2),
 			new SimpleObject(aBush2, 2, 4, 0, 2)
 		]), 0,
 		avoidClasses(
 			clWater, 4,
 			clHill, 1,
 			clPlayerTerritory, 0,
 			clGaia, 1,
 			clDirt, 1),
 		8 * scaleByMapSize(13, 200), 50);
 
 log("Creating deer...");
 	createObjectGroupsDeprecated(
 		new SimpleGroup([new SimpleObject(oDeer, 5, 7, 0, 4)], true, clFood),
 		0,
 		avoidClasses(
 			clWater, 4,
 			clForest, 0,
 			clPlayerTerritory, 0,
 			clGaia, 1,
 			clHill, 1,
 			clFood, 20),
 		3 * numPlayers,
 		50);
 
 log("Creating boar...");
 	createObjectGroupsDeprecated(
 		new SimpleGroup([new SimpleObject(oBoar, 2, 4, 0, 4)], true, clFood),
 		0,
 		avoidClasses(
 			clWater, 4,
 			clForest, 0,
 			clPlayerTerritory, 0,
 			clGaia, 1,
 			clHill, 1,
 			clFood, 20),
 		3 * numPlayers,
 		50);
 
 log("Creating tigers...");
 createObjectGroupsDeprecated(
 	new SimpleGroup([new SimpleObject(oTiger, 1, 1, 0, 4)], true, clFood),
 	0,
 	avoidClasses(
 		clWater, 4,
 		clForest, 0,
 		clPlayerTerritory, 0,
 		clGaia, 1,
 		clHill, 1,
 		clFood, 20),
 	3 * numPlayers,
 	50);
 RMS.SetProgress(95);
 
 log("Creating berry bush...");
 createObjectGroupsDeprecated(
 	new SimpleGroup([new SimpleObject(oBush, 5, 7, 0, 4)], true, clFood),
 	0,
 	avoidClasses(
 		clWater, 4,
 		clForest, 0,
 		clPlayerTerritory, 0,
 		clGaia, 1,
 		clHill, 1,
 		clFood, 10),
 		randIntInclusive(1, 4) * numPlayers + 2,
 		50);
 
 log("Creating fish...");
 createObjectGroupsDeprecated(
 	new SimpleGroup([new SimpleObject(oFish, 2, 3, 0, 2)], true, clFood),
 	0,
 	[avoidClasses(clFood, 15), stayClasses(clWater, 4)],
 	200,
 	100);
 
 setSunColor(0.6, 0.6, 0.6);
 setSunElevation(PI/ 3);
 
 setWaterColor(0.424, 0.534, 0.639);
 setWaterTint(0.369, 0.765, 0.745);
 setWaterWaviness(1.0);
 setWaterType("default");
 setWaterMurkiness(0.35);
 
 setFogFactor(0.03);
 setFogThickness(0.2);
 
 setPPEffect("hdr");
 setPPContrast(0.7);
 setPPSaturation(0.65);
 setPPBloom(0.6);
 
 setSkySet("stratus");
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/river_archipelago.json
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/river_archipelago.json	(revision 20263)
+++ ps/trunk/binaries/data/mods/public/maps/random/river_archipelago.json	(revision 20264)
@@ -1,12 +1,12 @@
 {
 	"settings" : {
 		"Name" : "River Archipelago",
 		"Script" : "river_archipelago.js",
 		"Description" : "Narrow strips of lands are separated by waterways, leaving few and shallow landbridges between them. Tropical wetlands provide plenty of game, but beware of Mauryan tribesmen when exploring the outermost islands.",
 		"BaseTerrain" : ["tropic_grass_c", "tropic_grass_c", "tropic_grass_c", "tropic_grass_c", "tropic_grass_plants", "tropic_plants", "tropic_plants_b"],
-		"BaseHeight" : 3,
+		"BaseHeight" : -8,
 		"Keywords": ["naval"],
 		"Preview" : "river_archipelago.png",
 		"CircularMap" : true
 	}
 }