Index: ps/trunk/binaries/data/mods/public/maps/random/alpine_lakes.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/alpine_lakes.js	(revision 19285)
+++ ps/trunk/binaries/data/mods/public/maps/random/alpine_lakes.js	(revision 19286)
@@ -1,422 +1,414 @@
 RMS.LoadLibrary("rmgen");
 
 //set up the random terrain
 var random_var = randInt(1,2);
 
 //late spring
 if (random_var == 1)
 {
 	setFogThickness(0.26);
 	setFogFactor(0.4);
 
 	setPPEffect("hdr");
 	setPPSaturation(0.48);
 	setPPContrast(0.53);
 	setPPBloom(0.12);
 
 	var tPrimary = ["alpine_dirt_grass_50"];
 	var tForestFloor = "alpine_forrestfloor";
 	var tCliff = ["alpine_cliff_a", "alpine_cliff_b", "alpine_cliff_c"];
 	var tSecondary = "alpine_grass_rocky";
 	var tHalfSnow = ["alpine_grass_snow_50", "alpine_dirt_snow"];
 	var tSnowLimited = ["alpine_snow_rocky"];
 	var 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];
 
 log("Initializing map...");
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 const mapArea = mapSize*mapSize;
 
 // create tile classes
 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 clSettlement = createTileClass();
 
 //cover the ground with the primary terrain chosen in the beginning
 for (var ix = 0; ix < mapSize; ix++)
 {
 	for (var iz = 0; iz < mapSize; iz++)
 	{
 		var x = ix / (mapSize + 1.0);
 		var z = iz / (mapSize + 1.0);
 			placeTerrain(ix, iz, tPrimary);
 	}
 }
 
 // randomize player order
 var playerIDs = [];
 for (var i = 0; i < numPlayers; i++)
 {
 	playerIDs.push(i+1);
 }
 playerIDs = sortPlayers(playerIDs);
 
 // place players
 var playerX = new Array(numPlayers);
 var playerZ = new Array(numPlayers);
 var playerAngle = new Array(numPlayers);
 
 var startAngle = randFloat(0, TWO_PI);
 for (var i = 0; i < numPlayers; i++)
 {
 	playerAngle[i] = startAngle + i*TWO_PI/numPlayers;
 	playerX[i] = 0.5 + 0.35*cos(playerAngle[i]);
 	playerZ[i] = 0.5 + 0.35*sin(playerAngle[i]);
 }
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	// some constants
 	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);
 	addToClass(ix, iz, clPlayer);
 	addToClass(ix+5, iz, clPlayer);
 	addToClass(ix, iz+5, clPlayer);
 	addToClass(ix-5, iz, clPlayer);
 	addToClass(ix, iz-5, 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);
 
 	// create starting units
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oBerryBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 	var hillSize = PI * radius * radius;
 	// create starting trees
 	var num = floor(hillSize / 100);
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(11, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oPine, num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 
 RMS.SetProgress(20);
 
 // create hills
 log("Creating hills...");
 createMountains(tCliff, avoidClasses(clPlayer, 20, clHill, 8), clHill, scaleByMapSize(10, 40) * numPlayers, floor(scaleByMapSize(40, 60)), floor(scaleByMapSize(4, 5)), floor(scaleByMapSize(7, 15)), floor(scaleByMapSize(5, 15)));
 
 RMS.SetProgress(30);
 
 var lakeAreas = [];
 var playerConstraint = new AvoidTileClassConstraint(clPlayer, 20);
 var waterConstraint = new AvoidTileClassConstraint(clWater, 8);
 
 for (var x = 0; x < mapSize; ++x)
 	for (var z = 0; z < mapSize; ++z)
 		if (playerConstraint.allows(x, z) && waterConstraint.allows(x, z))
 			lakeAreas.push([x, z]);
 
 var chosenPoint;
 var lakeAreaLen;
 
 // create lakes
 log("Creating lakes...");
 
 var numLakes = scaleByMapSize(5, 16);
 for (var i = 0; i < numLakes; ++i)
 {
 	lakeAreaLen = lakeAreas.length;
 	if (!lakeAreaLen)
 		break;
 
 	chosenPoint = lakeAreas[randInt(lakeAreaLen)];
 
 	placer = new ChainPlacer(1, floor(scaleByMapSize(4, 8)), floor(scaleByMapSize(40, 180)), 0.7, chosenPoint[0], chosenPoint[1]);
 	var terrainPainter = new LayeredPainter(
 		[tShore, tWater, tWater],		// terrains
 		[1, 3]								// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -5, 5);
 	var newLake = createAreas(
 		placer,
 		[terrainPainter, elevationPainter, paintClass(clWater)],
 		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);
 
 // create bumps
 createBumps(avoidClasses(clWater, 2, clPlayer, 20));
 
 // create forests
 createForests(
  [tPrimary, tForestFloor, tForestFloor, pForest, pForest],
  avoidClasses(clPlayer, 20, clForest, 17, clHill, 0, clWater, 2),
  clForest,
  1.0
 );
 
 RMS.SetProgress(60);
 
 // create dirt patches
 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)
 );
 
 // create grass patches
 log("Creating grass patches...");
 createPatches(
  [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
  tSecondary,
  avoidClasses(clWater, 3, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12)
 );
 
 RMS.SetProgress(65);
 
 log("Creating stone mines...");
 // create stone quarries
 createMines(
  [
   [new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)],
   [new SimpleObject(oStoneSmall, 2,5, 1,3)]
  ],
  avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clRock, 10, clHill, 1)
 );
 
 log("Creating metal mines...");
 // create large metal quarries
 createMines(
  [
   [new SimpleObject(oMetalLarge, 1,1, 0,4)]
  ],
  avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 1),
  clMetal
 );
 
 RMS.SetProgress(70);
 
 // create 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(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0)
 );
 
 RMS.SetProgress(75);
 
 // create animals
 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)
 );
 
 // create fruits
 createFood
 (
  [
   [new SimpleObject(oBerryBush, 5,7, 0,4)]
  ],
  [
   randInt(1, 4) * numPlayers + 2
  ],
  avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 10)
 );
 
 // create fish
 createFood
 (
  [
   [new SimpleObject(oFish, 2,3, 0,2)]
  ],
  [
   15 * numPlayers
  ],
  [avoidClasses(clFood, 20), stayClasses(clWater, 6)]
 );
 
 RMS.SetProgress(85);
 
 // create straggler trees
 var types = [oPine];
 createStragglerTrees(types, avoidClasses(clWater, 5, clForest, 3, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6));
 
-random_var = randInt(1,3);
-
-if (random_var==1)
-	setSkySet("cirrus");
-else if (random_var ==2)
-	setSkySet("cumulus");
-else if (random_var ==3)
-	setSkySet("sunny");
-
+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");
 
 // Export map data
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/alpine_valley.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/alpine_valley.js	(revision 19285)
+++ ps/trunk/binaries/data/mods/public/maps/random/alpine_valley.js	(revision 19286)
@@ -1,649 +1,642 @@
 RMS.LoadLibrary("rmgen");
 
 TILE_CENTERED_HEIGHT_MAP = true;
 
 //set up the random terrain
 var random_terrain = randInt(1,2);
 
 //late spring
 if (random_terrain == 1)
 {
 	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 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
 {
 	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 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];
 
 log("Initializing map...");
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 const mapArea = mapSize*mapSize;
 
 // create tile classes
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clSettlement = createTileClass();
 
 //cover the ground with the primary terrain chosen in the beginning
 for (var ix = 0; ix < mapSize; ix++)
 	for (var iz = 0; iz < mapSize; iz++)
 	{
 		var x = ix / (mapSize + 1.0);
 		var z = iz / (mapSize + 1.0);
 			placeTerrain(ix, iz, tPrimary);
 	}
 
 // randomize player order
 var playerIDs = [];
 for (var i = 0; i < numPlayers; i++)
 	playerIDs.push(i+1);
 
 playerIDs = sortPlayers(playerIDs);
 
 // place players
 var playerX = [];
 var playerZ = [];
 var playerAngle = [];
 
 var startAngle = randFloat(0, TWO_PI);
 for (var i = 0; i < numPlayers; i++)
 {
 	playerAngle[i] = startAngle + i*TWO_PI/numPlayers;
 	playerX[i] = 0.5 + 0.35*cos(playerAngle[i]);
 	playerZ[i] = 0.5 + 0.35*sin(playerAngle[i]);
 }
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	// some constants
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	ix = round(fx);
 	iz = round(fz);
 	addToClass(ix, iz, clPlayer);
 	addToClass(ix+5, iz, clPlayer);
 	addToClass(ix, iz+5, clPlayer);
 	addToClass(ix-5, iz, clPlayer);
 	addToClass(ix, iz-5, clPlayer);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tRoadWild, tRoad], [1]);
 	createArea(placer, painter, null);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oBerryBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 		mAngle = randFloat(0, TWO_PI);
 
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 	var hillSize = PI * radius * radius;
 	// create starting trees
 	var num = floor(hillSize / 100);
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(11, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oPine, num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 RMS.SetProgress(20);
 
 //place the mountains
 var points = [];
 
 var edgesConncetedToPoints = [];
 
 //we want the points near the start locations be the first ones. hence we use two "for" blocks
 for (var i = 0; i < numPlayers; ++i)
 {
 	playerAngle[i] = startAngle + (i+0.5)*TWO_PI/numPlayers;
 	points.push([round(fractionToTiles(0.5 + 0.49 * cos(playerAngle[i]))), round(fractionToTiles(0.5 + 0.49 * sin(playerAngle[i])))]);
 }
 
 //the order of the other points doesn't matter
 for (var i = 0; i < numPlayers; ++i)
 {
 	playerAngle[i] = startAngle + (i+0.7)*TWO_PI/numPlayers;
 	points.push([round(fractionToTiles(0.5 + 0.34 * cos(playerAngle[i]))), round(fractionToTiles(0.5 + 0.34 * sin(playerAngle[i])))]);
 	playerAngle[i] = startAngle + (i+0.3)*TWO_PI/numPlayers;
 	points.push([round(fractionToTiles(0.5 + 0.34 * cos(playerAngle[i]))), round(fractionToTiles(0.5 + 0.34 * sin(playerAngle[i])))]);
 	playerAngle[i] = startAngle + (i+0.5)*TWO_PI/numPlayers;
 	points.push([round(fractionToTiles(0.5 + 0.18 * cos(playerAngle[i]))), round(fractionToTiles(0.5 + 0.18 * sin(playerAngle[i])))]);
 }
 
 //add the center of the map
 points.push([round(fractionToTiles(0.5)), round(fractionToTiles(0.5))]);
 
 var numPoints = numPlayers * 4 + 1;
 
 for (var i = 0; i < numPoints; ++i)
 	edgesConncetedToPoints.push(0);
 
 //we are making a planar graph where every edge is a straight line.
 var possibleEdges = [];
 
 //add all of the possible combinations
 for (var i = 0; i < numPoints; ++i)
 	for (var j = numPlayers; j < numPoints; ++j)
 		if (j > i)
 			possibleEdges.push([i,j]);
 
 //we need a matrix so that we can prevent the mountain ranges from bocking a player
 var matrix = [];
 for (var i = 0; i < numPoints; ++i)
 {
 	matrix.push([]);
 	for (var j = 0; j < numPoints; ++j)
 		matrix[i].push(i < numPlayers && j < numPlayers && i != j && (i == j - 1 || i == j + 1))
 }
 
 //find and place the edges
 while (possibleEdges.length)
 {
 	var index = randInt(0, possibleEdges.length - 1);
 
 	//ensure that a point is connected to a maximum of 3 others
 	if (edgesConncetedToPoints[possibleEdges[index][0]] > 2 || edgesConncetedToPoints[possibleEdges[index][1]] > 2)
 	{
 		possibleEdges.splice(index,1);
 		continue;
 	}
 
 	//we don't want ranges that are longer than half of the map's size
 	if ((((points[possibleEdges[index][0]][0] - points[possibleEdges[index][1]][0]) *
 		(points[possibleEdges[index][0]][0] - points[possibleEdges[index][1]][0])) +
 		((points[possibleEdges[index][0]][1] - points[possibleEdges[index][1]][1]) *
 		(points[possibleEdges[index][0]][1] - points[possibleEdges[index][1]][1]))) >
 		mapArea)
 	{
 		possibleEdges.splice(index,1);
 		continue;
 	}
 
 	//dfs
 	var q = [possibleEdges[index][0]];
 
 	matrix[possibleEdges[index][0]][possibleEdges[index][1]] = true;
 	matrix[possibleEdges[index][1]][possibleEdges[index][0]] = true;
 	var selected, accept = true, tree = [], backtree = [];
 	while (q.length > 0)
 	{
 		selected = q.shift();
 		if (tree.indexOf(selected) == -1)
 		{
 			tree.push(selected);
 			backtree.push(-1);
 		}
 
 		for (var i = 0; i < numPoints; ++i)
 			if (matrix[selected][i])
 			{
 				if (i == backtree[tree.lastIndexOf(selected)])
 					continue;
 
 				if (tree.indexOf(i) == -1)
 				{
 					tree.push(i);
 					backtree.push(selected);
 					q.unshift(i);
 				}
 				else
 				{
 					accept = false;
 					matrix[possibleEdges[index][0]][possibleEdges[index][1]] = false;
 					matrix[possibleEdges[index][1]][possibleEdges[index][0]] = false;
 					break;
 				}
 			}
 	}
 
 	if (!accept)
 	{
 		possibleEdges.splice(index,1);
 		continue;
 	}
 
 	var ix = points[possibleEdges[index][0]][0];
 	var iz = points[possibleEdges[index][0]][1];
 	var ix2 = points[possibleEdges[index][1]][0];
 	var iz2 = points[possibleEdges[index][1]][1];
 	var placer = new PathPlacer(ix, iz, ix2, iz2, scaleByMapSize(9,15), 0.4, 3*(scaleByMapSize(1,4)), 0.1, 0.1, 0.1);
 	var terrainPainter = new LayeredPainter(
 		[tCliff, tPrimary],		// terrains
 		[3]		// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		30,				// elevation
 		2				// blend radius
 	);
 	accept = createArea(placer, [terrainPainter, elevationPainter, paintClass(clHill)], avoidClasses(clPlayer, 20));
 
 	if (accept == null)
 	{
 		matrix[possibleEdges[index][0]][possibleEdges[index][1]] = false;
 		matrix[possibleEdges[index][1]][possibleEdges[index][0]] = false;
 		possibleEdges.splice(index,1);
 		continue;
 	}
 	else
 	{
 		placer = new ClumpPlacer(floor(PI*scaleByMapSize(9,15)*scaleByMapSize(9,15)/4), 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tPrimary],		// terrains
 			[3]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			30,				// elevation
 			2				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clHill)], avoidClasses(clPlayer, 5));
 
 		placer = new ClumpPlacer(floor(PI*scaleByMapSize(9,15)*scaleByMapSize(9,15)/4), 0.95, 0.6, 10, ix2, iz2);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tPrimary],		// terrains
 			[3]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			30,				// elevation
 			2				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clHill)], avoidClasses(clPlayer, 5));
 	}
 
 	for (var i = 0; i < possibleEdges.length; ++i)
 	{
 		if (possibleEdges[index][0] != possibleEdges[i][0] && possibleEdges[index][1] != possibleEdges[i][0] &&
 			possibleEdges[index][0] != possibleEdges[i][1] && possibleEdges[index][1] != possibleEdges[i][1])
 		{
 
 			if (checkIfIntersect (points[possibleEdges[index][0]][0], points[possibleEdges[index][0]][1],
 				points[possibleEdges[index][1]][0], points[possibleEdges[index][1]][1], points[possibleEdges[i][0]][0],
 				points[possibleEdges[i][0]][1], points[possibleEdges[i][1]][0], points[possibleEdges[i][1]][1], scaleByMapSize(9,15) + scaleByMapSize(10,15)))
 			{
 				possibleEdges.splice(i,1);
 				--i;
 				if (index > i)
 					--index;
 			}
 		}
 		else if (((possibleEdges[index][0] == possibleEdges[i][0] && possibleEdges[index][1] != possibleEdges[i][1]) ||
 			(possibleEdges[index][1] == possibleEdges[i][0] && possibleEdges[index][0] != possibleEdges[i][1])) &&
 			distanceOfPointFromLine(points[possibleEdges[index][0]][0],points[possibleEdges[index][0]][1],
 			points[possibleEdges[index][1]][0], points[possibleEdges[index][1]][1],points[possibleEdges[i][1]][0], points[possibleEdges[i][1]][1])
 			< scaleByMapSize(9,15) + scaleByMapSize(10,15))
 		{
 			possibleEdges.splice(i,1);
 			--i;
 			if (index > i)
 				--index;
 		}
 		else if (((possibleEdges[index][0] == possibleEdges[i][1] && possibleEdges[index][1] != possibleEdges[i][0]) ||
 			(possibleEdges[index][1] == possibleEdges[i][1] && possibleEdges[index][0] != possibleEdges[i][0])) &&
 			distanceOfPointFromLine(points[possibleEdges[index][0]][0],points[possibleEdges[index][0]][1],
 			points[possibleEdges[index][1]][0], points[possibleEdges[index][1]][1],points[possibleEdges[i][0]][0], points[possibleEdges[i][0]][1])
 			< scaleByMapSize(9,15) + scaleByMapSize(10,15))
 		{
 			possibleEdges.splice(i,1);
 			--i;
 			if (index > i)
 				--index;
 		}
 
 	}
 
 	edgesConncetedToPoints[possibleEdges[index][0]] += 1;
 	edgesConncetedToPoints[possibleEdges[index][1]] += 1;
 
 	possibleEdges.splice(index,1);
 }
 
 paintTerrainBasedOnHeight(3.1, 29, 0, tCliff);
 paintTerrainBasedOnHeight(29, 30, 3, tSnowLimited);
 
 log("Creating bumps...");
 placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1);
 painter = new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2);
 createAreas(
 	placer,
 	painter,
 	avoidClasses(clPlayer, 10),
 	scaleByMapSize(100, 200)
 );
 RMS.SetProgress(40);
 
 log("Creating hills...");
 placer = new ClumpPlacer(scaleByMapSize(40, 150), 0.2, 0.1, 1);
 var terrainPainter = new LayeredPainter(
 	[tCliff, tSnowLimited],		// terrains
 	[2]								// widths
 );
 var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 30, 2);
 createAreas(
 	placer,
 	[terrainPainter, elevationPainter, paintClass(clHill)],
 	avoidClasses(clPlayer, 20, clHill, 14),
 	scaleByMapSize(10, 80) * numPlayers
 );
 RMS.SetProgress(50);
 
 // calculate desired number of trees for map (based on size)
 var MIN_TREES = 500;
 var MAX_TREES = 3000;
 var P_FOREST = 0.7;
 
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 var numForest = totalTrees * P_FOREST;
 var numStragglers = totalTrees * (1.0 - P_FOREST);
 
 log("Creating forests...");
 var types = [
 	[[tForestFloor, tPrimary, pForest], [tForestFloor, pForest]]
 ];	// some variation
 
 var size = numForest / (scaleByMapSize(2,8) * numPlayers);
 
 var num = floor(size / types.length);
 for (var i = 0; i < types.length; ++i)
 {
 	placer = new ClumpPlacer(numForest / num, 0.1, 0.1, 1);
 	painter = new LayeredPainter(
 		types[i],		// terrains
 		[2]											// widths
 		);
 	createAreas(
 		placer,
 		[painter, paintClass(clForest)],
 		avoidClasses(clPlayer, 12, clForest, 10, clHill, 0),
 		num
 	);
 }
 RMS.SetProgress(60);
 
 log("Creating dirt patches...");
 var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
 for (var i = 0; i < sizes.length; i++)
 {
 	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
 	painter = new LayeredPainter(
 		[[tDirt,tHalfSnow], [tHalfSnow,tSnowLimited]], 		// terrains
 		[2]															// widths
 	);
 	createAreas(
 		placer,
 		[painter, paintClass(clDirt)],
 		avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12),
 		scaleByMapSize(15, 45)
 	);
 }
 
 log("Creating grass patches...");
 var sizes = [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)];
 for (var i = 0; i < sizes.length; i++)
 {
 	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
 	painter = new TerrainPainter(tSecondary);
 	createAreas(
 		placer,
 		painter,
 		avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12),
 		scaleByMapSize(15, 45)
 	);
 }
 RMS.SetProgress(65);
 
 log("Creating stone mines...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
 createObjectGroups(group, 0,
 	avoidClasses(clForest, 1, clPlayer, 20, clRock, 10, clHill, 1),
 	scaleByMapSize(4,16), 100
 );
 
 log("Creating small stone mines...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroups(group, 0,
 	avoidClasses(clForest, 1, clPlayer, 20, clRock, 10, clHill, 1),
 	scaleByMapSize(4,16), 100
 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroups(group, 0,
 	avoidClasses(clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 1),
 	scaleByMapSize(4,16), 100
 );
 RMS.SetProgress(70);
 
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockMedium, 1,3, 0,1)],
 	true
 );
 createObjectGroups(
 	group, 0,
 	avoidClasses(clForest, 0, clPlayer, 0, clHill, 0),
 	scaleByMapSize(16, 262), 50
 );
 
 log("Creating large decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
 	true
 );
 createObjectGroups(
 	group, 0,
 	avoidClasses(clForest, 0, clPlayer, 0, clHill, 0),
 	scaleByMapSize(8, 131), 50
 );
 RMS.SetProgress(75);
 
 log("Creating deer...");
 group = new SimpleGroup(
 	[new SimpleObject(oDeer, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroups(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 10, clHill, 1, clFood, 20),
 	3 * numPlayers, 50
 );
 
 log("Creating berry bush...");
 group = new SimpleGroup(
 	[new SimpleObject(oBerryBush, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroups(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 20, clHill, 1, clFood, 10),
 	randInt(1, 4) * numPlayers + 2, 50
 );
 
 log("Creating rabbit...");
 group = new SimpleGroup(
 	[new SimpleObject(oRabbit, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroups(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 10, clHill, 1, clFood, 20),
 	3 * numPlayers, 50
 );
 RMS.SetProgress(85);
 
 log("Creating straggler trees...");
 var types = [oPine, oPine];	// some variation
 var num = floor(numStragglers / types.length);
 for (var i = 0; i < types.length; ++i)
 {
 	group = new SimpleGroup(
 		[new SimpleObject(types[i], 1,1, 0,3)],
 		true, clForest
 	);
 	createObjectGroups(group, 0,
 		avoidClasses(clForest, 1, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6),
 		num
 	);
 }
 
 log("Creating small grass tufts...");
 var planetm = 1;
 
 group = new SimpleGroup(
 	[new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)]
 );
 createObjectGroups(group, 0,
 	avoidClasses(clHill, 2, clPlayer, 2, clDirt, 0),
 	planetm * scaleByMapSize(13, 200)
 );
 RMS.SetProgress(90);
 
 log("Creating large grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aGrass, 2,4, 0,1.8, -PI/8,PI/8), new SimpleObject(aGrassShort, 3,6, 1.2,2.5, -PI/8,PI/8)]
 );
 createObjectGroups(group, 0,
 	avoidClasses(clHill, 2, clPlayer, 2, clDirt, 1, clForest, 0),
 	planetm * scaleByMapSize(13, 200)
 );
 RMS.SetProgress(95);
 
 log("Creating bushes...");
 group = new SimpleGroup(
 	[new SimpleObject(aBushMedium, 1,2, 0,2), new SimpleObject(aBushSmall, 2,4, 0,2)]
 );
 createObjectGroups(group, 0,
 	avoidClasses(clHill, 1, clPlayer, 1, clDirt, 1),
 	planetm * scaleByMapSize(13, 200), 50
 );
 
-random_terrain = randInt(1,3);
-if (random_terrain == 1)
-	setSkySet("cirrus");
-else if (random_terrain == 2)
-	setSkySet("cumulus");
-else if (random_terrain == 3)
-	setSkySet("sunny");
-
+setSkySet(pickRandom(["cirrus", "cumulus", "sunny"]));
 setSunRotation(randFloat(0, TWO_PI));
 setSunElevation(randFloat(PI/ 5, PI / 3));
 setWaterColor(0.0, 0.047, 0.286);				// dark majestic blue
 setWaterTint(0.471, 0.776, 0.863);				// light blue
 setWaterMurkiness(0.72);
 setWaterWaviness(2.0);
 setWaterType("lake");
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/corsica.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/corsica.js	(revision 19285)
+++ ps/trunk/binaries/data/mods/public/maps/random/corsica.js	(revision 19286)
@@ -1,719 +1,718 @@
 RMS.LoadLibrary("rmgen");
 
 var tGrass = ["medit_grass_field", "medit_grass_field_b", "temp_grass_c"];
 var tDune = ["medit_grass_field_brown"];
 var tBigDune = ["medit_grass_field_brown"];
 var tGrassPForest = "forestfloor_dirty";
 var tForestFloor = "medit_grass_shrubs";
 var tGrassA = ["desert_dirt_persia_1", "desert_dirt_persia_2"];
 var tGrassB = "dirta";
 var tLushGrass = ["medit_grass_field","medit_grass_field_a"];
 
 var tSteepCliffs = ["temp_cliff_b", "temp_cliff_a"];
 var tCliffs = ["temp_cliff_b", "medit_cliff_italia", "medit_cliff_italia_grass"];
 var tHill = ["medit_cliff_italia_grass","medit_cliff_italia_grass", "medit_grass_field", "medit_grass_field", "temp_grass"];
 var tMountain = ["medit_cliff_italia_grass","medit_cliff_italia"];
 var tMountainTop = ["medit_cliff_italia"];
 
 var tDirt = ["medit_dirt", "medit_dirt_b"];
 var tRoad = ["medit_city_tile","medit_rocks_grass","medit_grass_field_b"];
 var tRoadWild = ["medit_rocks_grass","medit_grass_field_b"];
 var tGrassPatch = "medit_dirt_b";
 
 var tShoreBlend = ["medit_sand_wet","medit_rocks_wet"];
 var tShore = ["medit_rocks","medit_sand","medit_sand"];
 var tSandTransition = ["medit_sand","medit_rocks_grass","medit_rocks_grass","medit_rocks_grass"];
 var tVeryDeepWater = ["medit_sea_depths","medit_sea_coral_deep"];
 var tDeepWater = ["medit_sea_coral_deep","tropic_ocean_coral"];
 var tCreekWater = "medit_sea_coral_plants";
 
 // gaia entities
 var ePine = "gaia/flora_tree_aleppo_pine";
 var ePalmTall = "gaia/flora_tree_cretan_date_palm_tall";
 var eFanPalm = "gaia/flora_tree_medit_fan_palm";
 var eCypress = "gaia/flora_tree_cypress";
 var eApple = "gaia/flora_tree_apple";
 var eBush = "gaia/flora_bush_berry";
 var eFish = "gaia/fauna_fish";
 var ePig = "gaia/fauna_pig";
 var eStoneMine = "gaia/geology_stonemine_medit_quarry";
 var eMetalMine = "gaia/geology_metal_mediterranean_slabs";
 
 // decorative props
 var aFlower1 = "actor|props/flora/decals_flowers_daisies.xml";
 var aWaterFlower = "actor|props/flora/water_lillies.xml";
 var aReedsA = "actor|props/flora/reeds_pond_lush_a.xml";
 var aReedsB = "actor|props/flora/reeds_pond_lush_b.xml";
 var aRock = "actor|geology/stone_granite_med.xml";
 var aLargeRock = "actor|geology/stone_granite_large.xml";
 var aBushA = "actor|props/flora/bush_medit_sm_lush.xml";
 var aBushB = "actor|props/flora/bush_medit_me_lush.xml";
 var aPlantA = "actor|props/flora/plant_medit_artichoke.xml";
 var aPlantB = "actor|props/flora/grass_tufts_a.xml";
 var aPlantC = "actor|props/flora/grass_soft_tuft_a.xml";
 var aShorePlantA = "actor|props/flora/reeds_beach.xml";
 var aShorePlantB = "actor|props/flora/grass_temp_field_brown.xml";
 
 var aStandingStone = "actor|props/special/eyecandy/standing_stones.xml";
 
 var tForestNicae = [tForestFloor + TERRAIN_SEPARATOR + ePine,tForestFloor + TERRAIN_SEPARATOR + ePine,tForestFloor + TERRAIN_SEPARATOR + ePine,tForestFloor + TERRAIN_SEPARATOR + ePine,tForestFloor + TERRAIN_SEPARATOR + eFanPalm, tForestFloor + TERRAIN_SEPARATOR + ePalmTall, tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor];
 var tForestNicaeLight = [tForestFloor + TERRAIN_SEPARATOR + ePine,tForestFloor + TERRAIN_SEPARATOR + ePine,tForestFloor + TERRAIN_SEPARATOR + eFanPalm, tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor];
 var tForestNicaeScarce = [tForestFloor + TERRAIN_SEPARATOR + ePine,tForestFloor + TERRAIN_SEPARATOR + ePine,tForestFloor + TERRAIN_SEPARATOR + eFanPalm, tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor,tForestFloor];
 
 log("Initializing map...");
 
 InitMap();
 
 var numPlayers = getNumPlayers();
 var mapSize = getMapSize();
 var mapArea = mapSize*mapSize;
 
 // create tile classes
 var clCorsica = createTileClass();
 var clSardinia = createTileClass();
 var clCreek = createTileClass();
 
 var clWater = createTileClass();
 
 var clCliffs = createTileClass();
 var clForest = createTileClass();
 var clPeak = createTileClass();
 
 var clShore = createTileClass();
 var clPathToShore = createTileClass();
 var clPlayer = createTileClass();
 var clBaseResource = createTileClass();
 var clPassage = createTileClass();
 var clHill = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clSettlement = createTileClass();
 var clDune = createTileClass();
 
 // on every pixel of the map, set wet sand
 for (var ix = 0; ix < mapSize; ix++)
 {
 	for (var iz = 0; iz < mapSize; iz++)
 	{
 		var x = ix / (mapSize + 1.0);
 		var z = iz / (mapSize + 1.0);
 			placeTerrain(ix, iz, tVeryDeepWater);
 		//addToClass(ix,iz,clWater);
 	}
 }
 
 // let's decide if we swap
 var swap = Math.round(Math.random());	// should return about 50/50 a 0 or a 1
 // let's create Corsica
 log("Creating Corsica");
 var CorsicaX = fractionToTiles(0.99);
 var CorsicaZ = fractionToTiles(0.9);
 if (swap)
 	CorsicaX = fractionToTiles(0.01);
 
 // Okay so the thing here is that we'll make a sort of jagged circle. To achieve this, I'll make a few islands
 // that will basically be put together
 // first, let's make a big round island in the corner.
 // okay so actually subdivided cleverly to make it work and give jagedness with the multiple islands
 var llx = round(CorsicaX);
 var llz = round(CorsicaZ);
 // okay so the circle reaches close to a third of the map
 var placer = new ClumpPlacer(fractionToSize(0.3)*1.8, 1.0, 0.5, 10, llx, llz);
 var terrainPainter = new LayeredPainter([tCliffs, tGrass], [2] );
 var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 5,0);
 createArea(placer, [terrainPainter, paintClass(clCorsica), elevationPainter], null);
 var nbSubIsland = 5;	// actually 5+1
 for (var i = 0; i <= nbSubIsland; i++)
 {
 	// radius is "sqrt(this.size / PI)"... so in my case it's "sqrt(fractionofSize(0.33)*2.0/PI), about 0.64, sqrt-ed
 	//Let's round down.
 	// only from π to 3π/2
 	var angle = (i * (-PI/(nbSubIsland*2)) + PI);
 	if (!swap)
 		angle *= -1;
 	var llx = round (CorsicaX + sqrt(fractionToSize(0.3)*0.55)*sin(angle));
 	var llz = round (CorsicaZ + sqrt(fractionToSize(0.3)*0.55)*cos(angle));
 	var placer = new ClumpPlacer(fractionToSize(0.05)/2, 0.6, 0.03, 10, llx, llz);
 	var terrainPainter = new LayeredPainter([tCliffs, tGrass], [2] );
 	var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 5,1);
 	createArea(placer, [terrainPainter, paintClass(clCorsica), elevationPainter], null);
 }
 RMS.SetProgress(10);
 
 log("Creating Sardinia");
 var SardiniaX = fractionToTiles(0.01);
 var SardiniaZ = fractionToTiles(0.1);
 if (swap)
 	SardiniaX = fractionToTiles(0.99);
 
 var llx = round(SardiniaX);
 var llz = round(SardiniaZ);
 // okay so the circle reaches close to a third of the map
 var placer = new ClumpPlacer(fractionToSize(0.3)*1.8, 1.0, 0.5, 10, llx, llz);
 var terrainPainter = new LayeredPainter([tCliffs, tGrass], [2] );
 var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 5,0);
 createArea(placer, [terrainPainter, paintClass(clSardinia), elevationPainter], null);
 // same as Corsica on the other side
 for (var i = 0; i <= nbSubIsland; i++)
 {
 	var angle = (i * (-PI/(nbSubIsland*2)));
 	if (!swap)
 		angle *= -1;
 	var llx = round (SardiniaX + sqrt(fractionToSize(0.3)*0.55)*sin(angle));
 	var llz = round (SardiniaZ + sqrt(fractionToSize(0.3)*0.55)*cos(angle));
 	var placer = new ClumpPlacer(fractionToSize(0.05)/2, 0.6, 0.03, 10, llx, llz);
 	var terrainPainter = new LayeredPainter([tCliffs, tGrass], [2] );
 	var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 5,1);
 	createArea(placer, [terrainPainter, paintClass(clSardinia), elevationPainter], null);
 }
 
 log("Creating Creeks");
 
 // okay so now let's make some cleverly designed creeks: this creates a very jagged relief, looks good
 var nbCreeks = scaleByMapSize(6,15);
 // inCorsica first
 var islandX = [SardiniaX,CorsicaX];
 var islandZ = [SardiniaZ,CorsicaZ];
 // first: the creeks
 for (var island = 0; island <= 1; island++)
 	for (var i = 0; i <= nbCreeks; i++)
 	{
 		var radius = fractionToTiles( (Math.random()/17) + 0.49);
 		var angle = PI*island + i*(PI/(nbCreeks*2));
 		if (swap)
 			angle += PI/2;
 		fx = radius * cos(angle);
 		fz = radius * sin(angle);
 		fx = round(islandX[island] + fx);
 		fz = round(islandZ[island] + fz);
 		var size = scaleByMapSize(75,100);
 		if (Math.random() > 0.5)
 			size = Math.random() * 40 + 10;
 		else
 			size += Math.random() * 20;
 		var placer = new ClumpPlacer(size, 0.4, 0.01, 10, fx,fz);
 		var terrainPainter = new TerrainPainter(tSteepCliffs);
 		var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -5,0);	// base height is -10
 		createArea(placer, [terrainPainter, paintClass(clCreek), elevationPainter], null);
 	}
 
 var nbBeaches = scaleByMapSize(2,5);
 for (var island = 0; island <= 1; island++)
 {
 	for (var i = 0; i <= nbBeaches; i++)
 	{
 		var smallRadius = fractionToTiles( 0.45);
 		var bigRadius = fractionToTiles( 0.57);
 		var angle = PI*island + i*(PI/(nbBeaches*2.5)) + PI/(nbBeaches*6) + randFloat(-PI/(nbBeaches*7),PI/(nbBeaches*7));
 		if (swap)
 			angle += PI/2;
 		var startX = smallRadius * cos(angle);
 		var startZ = smallRadius * sin(angle);
 		startX = round(islandX[island] + startX);
 		startZ = round(islandZ[island] + startZ);
 
 		var endX = bigRadius * cos(angle);
 		var endZ = bigRadius * sin(angle);
 		endX = round(islandX[island] + endX);
 		endZ = round(islandZ[island] + endZ);
 
 		var placer = new ClumpPlacer(130, 0.7, 0.8, 10, round((startX+endX*3)/4),round((startZ+endZ*3)/4));
 		var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -1,5);	// base height is -10
 		createArea(placer, [elevationPainter], null);
 
 		straightPassageMaker(startX, startZ,endX,endZ, 25, 18, 4,clShore,null);
 	}
 }
 RMS.SetProgress(20);
 log("Creating Main Relief");
 // Let's make it generally cliffy
 placer = new ClumpPlacer(fractionToSize(0.3)*1.8, 1.0, 0.2, 4,round((CorsicaX * 5 + fractionToTiles(0.5)) / 6.0),round(fractionToTiles(0.8)));
 elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, 30,fractionToTiles(0.45));
 createArea( placer, [elevationPainter],  null);
 placer = new ClumpPlacer(fractionToSize(0.3)*1.8, 1.0, 0.2, 4,round((SardiniaX * 5 + fractionToTiles(0.5)) / 6.0),round(fractionToTiles(0.2)));
 elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, 30,fractionToTiles(0.45));
 createArea( placer, [elevationPainter],  null);
 
 log("Creating players");
 
 // randomize player order
 var playerIDs = [];
 for (var i = 0; i < numPlayers; i++)
 {
 	playerIDs.push(i+1);
 }
 playerIDs = sortPlayers(playerIDs);
 
 // place players
 var playerX = new Array(numPlayers);
 var playerZ = new Array(numPlayers);
 var playerAngle = new Array(numPlayers);
 
 var island = 0;
 var formerTeam = getPlayerTeam(0);
 var onCorsica = [];
 var onSardinia = [];
 for (var o = 0; o < numPlayers; o++)
 {
 	if (getPlayerTeam(o) === formerTeam && formerTeam !== -1)
 	{
 		// same island
 		if (island === 0)
 			onCorsica.push(o);
 		else
 			onSardinia.push(o);
 	} else if (getPlayerTeam(o) !== -1){
 		if (island === 0)
 		{
 			island = 1;
 			onSardinia.push(o);
 		} else {
 			island = 0;
 			onCorsica.push(o);
 		}
 	} else {
 		// okay now the less crowded:
 		if (onCorsica.length > onSardinia.length)
 			onSardinia.push(o);
 		else
 			onCorsica.push(o);
 	}
 	formerTeam = getPlayerTeam(o);
 }
 // le'ts place the players in a circle around the island.
 for (var i = 0;i < onCorsica.length; i++)
 {
 	var angle = (i * (PI/(onCorsica.length*2)) + PI + PI/(4*onCorsica.length));
 	if (swap)
 		angle += PI/2;
 	playerAngle[onCorsica[i]] = angle;
 	playerX[onCorsica[i]] = round( CorsicaX + fractionToTiles(0.36*cos(angle)));
 	playerZ[onCorsica[i]] = round( fractionToTiles(1 + 0.36*sin(angle)));
 }
 for (var i = 0;i < onSardinia.length; i++)
 {
 	var angle = (i * (PI/(onSardinia.length*2)) + PI/(4*onSardinia.length));
 	if (swap)
 		angle += PI/2;
 	playerAngle[onSardinia[i]] = angle;
 	playerX[onSardinia[i]] = round( SardiniaX + fractionToTiles(0.36*cos(angle)));
 	playerZ[onSardinia[i]] = round( fractionToTiles(0 + 0.36*sin(angle)));
 }
 
 var placer = undefined;
 var fx = 0; var fz = 0;
 var ix =0; var iz = 0;
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	// some constants
 	var radius = 23;
 
 	// get the x and z in tiles
 	fx = playerX[i];
 	fz = playerZ[i];
 
 
 	// let's create a nice platform
 	var placer = new ClumpPlacer(PI*radius*radius, 0.95, 0.3, 10, fx,fz);
 	var PlayerArea = createArea(placer, [paintClass(clPlayer)], null);
 
 	// create the city patch
 	var cityRadius = radius/4;
 	placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.8, 0.3, 10, fx, fz);
 	var painter = new LayeredPainter([tRoadWild,tRoad],[1]);
 	var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, getHeight(fx,fz),10);
 	createArea(placer, [painter,paintClass(clSettlement),elevationPainter], null);
 
 	// create starting units
 	placeCivDefaultEntities(fx, fz, id, { 'iberWall': false });
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 11;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(eBush, 5,5, 1,2)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	// this makes sure it's created on the same level as the player.
 	var mAngle = randFloat(playerAngle[i] + PI/2,playerAngle[i] + PI/3);
 	var mDist = 18;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(eMetalMine, 1,1, 0,0),new SimpleObject(aBushB, 1,1, 2,2), new SimpleObject(aBushA, 0,2, 1,3), new SimpleObject(ePine, 0,1, 3,3)], true, clBaseResource, mX, mZ );
 	createObjectGroup(group, 0);
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/5);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(eStoneMine, 1,1, 0,2),new SimpleObject(aBushB, 1,1, 2,2), new SimpleObject(aBushA, 0,2, 1,3), new SimpleObject(ePine, 0,1, 3,3)], true, clBaseResource, mX, mZ );
 	createObjectGroup(group, 0);
 
 	group = new SimpleGroup([new SimpleObject(ePine, 1,3, 1,4),new SimpleObject(ePalmTall, 0,1, 1,4),new SimpleObject(eFanPalm, 0,1, 0,2)], true, clForest);
 	createObjectGroups(group, 0, [avoidClasses(clBaseResource,3, clSettlement,0), stayClasses(clPlayer,1)], 150, 1000);
 }
 
 RMS.SetProgress(40);
 log ("making plateaux");
 // Corsica and Sardinia
 
 var SardX = round((SardiniaX*5 + fractionToTiles(0.5))/6.0);
 var SardZ = round(fractionToTiles(0.1));
 var CorsX = round((CorsicaX*5 + fractionToTiles(0.5))/6.0);
 var CorsZ = round(fractionToTiles(0.9));
 // first level plateaux, puts the player higher
 placer = new ClumpPlacer(fractionToSize(0.18)*1.8, 0.95, 0.02, 4,CorsX,CorsZ);
 elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, 9,1);
 createArea( placer, [elevationPainter],  null);
 placer = new ClumpPlacer(fractionToSize(0.18)*1.8, 0.95, 0.02, 4,SardX,SardZ);
 elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, 9,1);
 createArea( placer, [elevationPainter],  null);
 // second level plateaux, top of the hill
 if(mapSize > 150)
 {
 	placer = new ClumpPlacer(fractionToSize(0.1), 0.98, 0.04, 4,CorsX,CorsZ);
 	terrainPainter = new LayeredPainter([tCliffs, tGrass], [2] );
 	elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, 8,1);
 	createArea( placer, [terrainPainter,elevationPainter],  null);
 	placer = new ClumpPlacer(fractionToSize(0.1), 0.98, 0.04, 4,SardX,SardZ);
 	terrainPainter = new LayeredPainter([tCliffs, tGrass], [2] );
 	elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, 8,1);
 	createArea( placer, [terrainPainter,elevationPainter],  null);
 }
 log ("creating passages towards the island");
 if(mapSize > 150)
 {
 	var nb = scaleByMapSize(1,4);
 	for (var i = 0; i < nb; i++) {
 		var radius = sqrt(fractionToSize(0.1)/PI);
 		var angle = PI + i*(PI/(2*nb)) + PI/(4*nb);
 		if (swap)
 			angle += PI/2;
 		var x1 = round(CorsX + (radius+5)*cos(angle));
 		var y1 = round(CorsZ + (radius+5)*sin(angle));
 		var x2 = round(CorsX + (radius-4)*cos(angle));
 		var y2 = round(CorsZ + (radius-4)*sin(angle));
 		straightPassageMaker(x1, y1, x2, y2, 1, 6, 2, clPassage, tGrass);
 	}
 	for (var i = 0; i < nb; i++) {
 		var radius = sqrt(fractionToSize(0.1)/PI)+ 2;
 		var angle = i*(PI/(2*nb)) + PI/(4*nb);
 		if (swap)
 			angle += PI/2;
 		var x1 = round(SardX + (radius+5)*cos(angle));
 		var y1 = round(SardZ + (radius+5)*sin(angle));
 		var x2 = round(SardX + (radius-4)*cos(angle));
 		var y2 = round(SardZ + (radius-4)*sin(angle));
 		straightPassageMaker(x1, y1, x2, y2, 1, 6, 2, clPassage, tGrass);
 	}
 }
 for (var i = 0; i <= 3; i++) {
 	var radius = sqrt(fractionToSize(0.18)*1.8/PI) + 2;
 	var angle = PI + i*(PI/7) + PI/9;
 	if (swap)
 		angle += PI/2;
 	var x1 = round(CorsX + (radius+7)*cos(angle));
 	var y1 = round(CorsZ + (radius+7)*sin(angle));
 	var x2 = round(CorsX + (radius-5)*cos(angle));
 	var y2 = round(CorsZ + (radius-5)*sin(angle));
 	straightPassageMaker(x1, y1, x2, y2, 4, 10, 3, clPassage, tGrass);
 }
 for (var i = 0; i <= 3; i++) {
 	var radius = sqrt(fractionToSize(0.18)*1.8/PI)+ 2;
 	var angle = i*(PI/7) + PI/9;
 	if (swap)
 		angle += PI/2;
 	var x1 = round(SardX + (radius+7)*cos(angle));
 	var y1 = round(SardZ + (radius+7)*sin(angle));
 	var x2 = round(SardX + (radius-5)*cos(angle));
 	var y2 = round(SardZ + (radius-5)*sin(angle));
 	straightPassageMaker(x1, y1, x2, y2, 4, 10, 3, clPassage, tGrass);
 }
 RMS.SetProgress(50);
 
 log ("creating bumps");
 placer = new ClumpPlacer(70, 0.6, 0.1, 4);
 elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, 2,3);
 createAreas( placer, [elevationPainter],  [avoidClasses(clPlayer,2,clPassage, 2), stayClasses(clCorsica,2)],scaleByMapSize(20,100), 5 );
 createAreas( placer, [elevationPainter],  [avoidClasses(clPlayer,2,clPassage, 2), stayClasses(clSardinia,2)],scaleByMapSize(20,100), 5 );
 
 log ("creating anti bumps");
 placer = new ClumpPlacer(120, 0.3, 0.1, 4);
 elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, -5,6);
 createAreas( placer, [elevationPainter],  [avoidClasses(clPlayer,2,clPassage, 2,clCorsica,2,clSardinia,2)],scaleByMapSize(20,100), 5 );
 
 
 log("Repainting");
 var terrTop = createTerrain(tMountainTop);
 var terrMount = createTerrain(tMountain);
 var terrHill = createTerrain(tHill);
 var terrCliff = createTerrain(tCliffs);
 var terrSteepCliff = createTerrain(tSteepCliffs);
 var terrGrass = createTerrain(tGrass);
 
 var terrShallow = createTerrain(tCreekWater);
 var terrDeep = createTerrain(tDeepWater);
 var terrDark = createTerrain(tVeryDeepWater);
 var terrSand = createTerrain(tShore);
 var terrWetSand = createTerrain(tShoreBlend);
 var terrSandTransition = createTerrain(tSandTransition);
 // first pass: who's water?
 for (var sandx = 0; sandx < mapSize; sandx++)
 	for (var sandz = 0; sandz < mapSize; sandz++)
 		if (getHeight(sandx,sandz) < 0)
 			addToClass(sandx,sandz,clWater);
 
 // second pass: who's not water
 for (var sandx = 0; sandx < mapSize; sandx++) {
 	for (var sandz = 0; sandz < mapSize; sandz++) {
 		if (getTileClass(clSettlement).countMembersInRadius(sandx,sandz,2) === 0)
 		{
 			var height = getHeight(sandx,sandz);
 			var heightDiff = getHeightDiff(sandx,sandz);
 			if (height >= 0.5 && height < 1.5 /*&& getTileClass(clWater).countMembersInRadius(sandx,sandz,3) > 0 */ && getTileClass(clShore).countMembersInRadius(sandx,sandz,2) > 0)
 			{
 				terrSandTransition.place(sandx,sandz);
 			} else if (height >= 1 && getTileClass(clWater).countMembersInRadius(sandx,sandz,3) == 0)
 			{
 				// paint hills or cliffs depending on terrain elevation difference
 				if (height > 17 && getTileClass(clPassage).countMembersInRadius(sandx,sandz,2) == 0)
 				{
 					if (heightDiff < 5)
 						terrHill.place(sandx,sandz);
 					else if(heightDiff < 10)
 						terrMount.place(sandx,sandz);
 				} else {
 					terrGrass.place(sandx,sandz);
 				}
 				if (height > 25 && heightDiff >= 10 && getTileClass(clPassage).countMembersInRadius(sandx,sandz,2) == 0) {
 					terrSteepCliff.place(sandx,sandz);
 					addToClass(sandx,sandz,clCliffs);
 				} else if(heightDiff >= 10 && getTileClass(clPassage).countMembersInRadius(sandx,sandz,2) == 0) {
 					terrCliff.place(sandx,sandz);
 					addToClass(sandx,sandz,clCliffs);
 				}
 			} else {
 				if (height >= 0 && heightDiff >= 9) {
 					terrCliff.place(sandx,sandz);
 					addToClass(sandx,sandz,clCliffs);
 				} else if (height >= -0.75 && height < 1.5 && heightDiff < 9) {
 						terrSand.place(sandx,sandz);
 				} else if (height >= -3  && height < -0.75 && heightDiff < 9) {
 					terrWetSand.place(sandx,sandz);
 				}  else if (height >= -6  && height < -3 && heightDiff < 9) {
 					terrShallow.place(sandx,sandz);
 				} else if (height > -10  && height < -6 && heightDiff < 6) {
 					terrDeep.place(sandx,sandz);
 				}
 				if (heightDiff >= 9) {
 					terrCliff.place(sandx,sandz);
 					addToClass(sandx,sandz,clCliffs);
 				}
 			}
 		}
 	}
 }
 
 RMS.SetProgress(65);
 
 log("Creating stone mines...");
 // create large stone quarries
 group = new SimpleGroup([new SimpleObject(eStoneMine, 1,1, 0,0),new SimpleObject(aBushB, 1,1, 2,2), new SimpleObject(aBushA, 0,2, 1,3)], true, clBaseResource);
 createObjectGroups(group, 0,[stayClasses(clCorsica, 1),avoidClasses(clWater, 3, clPlayer,2 , clBaseResource, 2,clCliffs,1)],  scaleByMapSize(6,25), 1000  );
 createObjectGroups(group, 0,[stayClasses(clSardinia, 1),avoidClasses(clWater, 3, clPlayer,2 , clBaseResource, 2,clCliffs,1)],  scaleByMapSize(6,25), 1000  );
 
 log("Creating metal mines...");
 // create large metal quarries
 group = new SimpleGroup([new SimpleObject(eMetalMine, 1,1, 0,0),new SimpleObject(aBushB, 1,1, 2,2), new SimpleObject(aBushA, 0,2, 1,3)], true, clBaseResource);
 createObjectGroups(group, 0,[avoidClasses(clWater, 3, clPlayer,2 , clBaseResource, 2,clCliffs,1),stayClasses(clCorsica, 1)],  scaleByMapSize(6,25), 1000  );
 createObjectGroups(group, 0,[avoidClasses(clWater, 3, clPlayer,2 , clBaseResource, 2,clCliffs,1),stayClasses(clSardinia, 1)],  scaleByMapSize(6,25), 1000  );
 
 log("Creating grass patches...");
 placer = new ClumpPlacer(20, 0.3, 0.06, 0.5);
 painter = new TerrainPainter(tLushGrass);
 createAreas( placer, [painter,paintClass(clForest)], avoidClasses(clWater, 1,clPlayer, 0,clBaseResource, 3,clCliffs,1), scaleByMapSize(10, 40) );
 
 log ("creating forests");
 var TreeGroup = new SimpleGroup([new SimpleObject(ePine, 3,6, 1,3),new SimpleObject(ePalmTall, 1,3, 1,3),new SimpleObject(eFanPalm, 0,2, 0,2),new SimpleObject(eApple, 0,1, 1,2)], true, clForest);
 createObjectGroups(TreeGroup, 0, [avoidClasses(clWater, 1, clForest, 0,clPlayer, 0,clBaseResource, 2,clCliffs,2), stayClasses(clCorsica, 3)],  scaleByMapSize(350,2500), 100 );
 createObjectGroups(TreeGroup, 0, [avoidClasses(clWater, 1, clForest, 0,clPlayer, 0,clBaseResource, 2,clCliffs,2), stayClasses(clSardinia, 3)],  scaleByMapSize(350,2500), 100 );
 
 RMS.SetProgress(75);
 
 
 // create small decorative rocks
 log("Creating small decorative rocks...");
 group = new SimpleGroup( [new SimpleObject(aRock, 1,3, 0,1),new SimpleObject(aStandingStone, 0,2, 0,3)], true );
 createObjectGroups( group, 0, avoidClasses(clWater, 0, clForest, 0, clPlayer, 0,clBaseResource, 0, clPassage, 2),
 	scaleByMapSize(16, 262), 50
 );
 
 
 // create large decorative rocks
 log("Creating large decorative rocks...");
 group = new SimpleGroup( [new SimpleObject(aLargeRock, 1,2, 0,1), new SimpleObject(aRock, 1,3, 0,2)], true
 );
 createObjectGroups( group, 0, avoidClasses(clWater, 0, clForest, 0, clPlayer, 0,clBaseResource, 0, clPassage, 2),
 	scaleByMapSize(8, 131), 50
 );
 createObjectGroups( group, 0, borderClasses(clWater, 5,10), scaleByMapSize(100,800), 500);
 
 // create decorative grass
 log("Creating beautification...");
 group = new SimpleGroup( [new SimpleObject(aPlantA, 3,7, 0,3),new SimpleObject(aPlantB, 3,6, 0,3),new SimpleObject(aPlantC, 1,4, 0,4)], true );
 createObjectGroups( group, 0, avoidClasses(clWater, 0,clBaseResource, 0, clShore,3), scaleByMapSize(100, 600), 50  );
 group = new SimpleGroup( [new SimpleObject(aPlantB, 5,20, 0,5),new SimpleObject(aPlantC, 4,10, 0,4)], true );
 createObjectGroups( group, 0, avoidClasses(clWater, 0,clBaseResource, 0, clShore,3), scaleByMapSize(100, 600), 50  );
 
 RMS.SetProgress(80);
 
 log("Creating animals...");
 group = new SimpleGroup( [new SimpleObject(ePig, 2,4, 0,3)] );
 createObjectGroups( group, 0, avoidClasses(clWater, 3,clBaseResource, 0), scaleByMapSize(20, 100), 50  );
 
 group = new SimpleGroup( [new SimpleObject(eFish, 1,2, 0,3)] );
 createObjectGroups( group, 0, [avoidClasses(clCreek,3,clShore,3),stayClasses(clWater, 3)], scaleByMapSize(50, 150), 100  );
 
 RMS.SetProgress(90);
 
 RMS.SetProgress(95);
-if (randFloat(0,1) > 0.5)
-	setSkySet("cumulus");
-else
-	setSkySet("sunny");
+
+setSkySet(pickRandom(["cumulus", "sunny"]));
+
 setSunColor(0.8,0.66,0.48);
 setSunElevation(0.828932);
 if (!swap)
 	setSunRotation(6.3*PI/8);
 else
 	setSunRotation(2.3*PI/8);
 setTerrainAmbientColor(0.564706,0.543726,0.419608);
 setUnitsAmbientColor(0.53,0.55,0.45);
 setWaterColor(0.2,0.294,0.49);
 setWaterTint(0.208, 0.659, 0.925);
 setWaterMurkiness(0.72);
 setWaterWaviness(2.0);
 setWaterType("ocean");
 // Export map data
 ExportMap();
 
 
 
 
 // this function will go from point [x1,z1] to point [x2,z2], while following a curve of width (starting-center-starting)
 // it can smooth on the side depending on "smooth", which is the distance of the smooth. Tileclass and Terrain set a tileclass/terrain
 // it effectively can create a smooth path from point [x1,z1] to point [x2,z2], ie Canyon, whatever.
 // note: NOT efficient for large distances: I'm widely oversampling
 function straightPassageMaker(x1, z1, x2, z2, startWidth, centerWidth, smooth, tileclass, terrain)
 {
 	var mapSize = g_Map.size;
 	var stepNB = sqrt((x2-x1)*(x2-x1) + (z2-z1)*(z2-z1)) + 2;
 
 	var startHeight = getHeight(x1,z1);
 	var finishHeight = getHeight(x2,z2);
 	for (var step = 0; step <= stepNB; step+=0.5)
 	{
 		var ix = ((stepNB-step)*x1 + x2*step) / stepNB;
 		var iz = ((stepNB-step)*z1 + z2*step) / stepNB;
 		// 5 at star/end, and 0 at the center
 		var width = (abs(step - stepNB/2.0) *startWidth + (stepNB/2 - abs(step - stepNB/2.0)) * centerWidth ) / (stepNB/2);
 		var oldDirection = [x2-x1, z2-z1];
 		// let's get the perpendicular direction
 		var direction = [ -oldDirection[1],oldDirection[0] ];
 		if (abs(direction[0]) > abs(direction[1]))
 		{
 			direction[1] = direction[1] / abs(direction[0]);
 			if (direction[0] > 0)
 				direction[0] = 1;
 			else
 				direction[0] = -1;
 		} else {
 			direction[0] = direction[0] / abs(direction[1]);
 			if (direction[1] > 0)
 				direction[1] = 1;
 			else
 				direction[1] = -1;
 		}
 		for (var po = -Math.floor(width/2.0); po <= Math.floor(width/2.0); po+=0.5)
 		{
 			var rx = po*direction[0];
 			var rz = po*direction[1];
 
 			var relativeWidth = abs(po / Math.floor(width/2));
 			var targetHeight = ((stepNB-step)*startHeight + finishHeight*step) / stepNB;
 			if (round(ix + rx) < mapSize && round(iz + rz) < mapSize && round(ix + rx) >= 0 && round(iz + rz) >= 0)
 			{
 				// smoothing the sides
 				if ( abs(abs(po) - abs(Math.floor(width/2.0))) < smooth)
 				{
 					var localHeight = getHeight(round(ix + rx), round(iz + rz));
 					var localPart = smooth - abs(abs(po) - abs(Math.floor(width/2.0)));
 					var targetHeight = (localHeight * localPart + targetHeight * (1/localPart) )/ (localPart + 1/localPart);
 				}
 
 				g_Map.setHeight(round(ix + rx), round(iz + rz), targetHeight);
 				if (tileclass !== null)
 					addToClass(round(ix + rx), round(iz + rz), tileclass);
 				if (terrain !== null)
 					placeTerrain(round(ix + rx), round(iz + rz), terrain);
 			}
 		}
 	}
 }
 // no need for preliminary rounding
 function getHeightDiff(x1, z1)
 {
 	var height = getHeight(round(x1),round(z1));
 	var diff = 0;
 	if (z1 + 1 < mapSize)
 		diff += abs(getHeight(round(x1),round(z1+1)) - height);
 	if (x1 + 1 < mapSize && z1 + 1 < mapSize)
 		diff += abs(getHeight(round(x1+1),round(z1+1)) - height);
 	if (x1 + 1 < mapSize)
 		diff += abs(getHeight(round(x1+1),round(z1)) - height);
 	if (x1 + 1 < mapSize && z1 - 1 >= 0)
 		diff += abs(getHeight(round(x1+1),round(z1-1)) - height);
 	if (z1 - 1 >= 0)
 		diff += abs(getHeight(round(x1),round(z1-1)) - height);
 	if (x1 - 1 >= 0 && z1 - 1 >= 0)
 		diff += abs(getHeight(round(x1-1),round(z1-1)) - height);
 	if (x1 - 1 >= 0)
 		diff += abs(getHeight(round(x1-1),round(z1)) - height);
 	if (x1 - 1 >= 0 && z1 + 1 < mapSize)
 		diff += abs(getHeight(round(x1-1),round(z1+1)) - height);
 	return diff;
 }
 function hasTextureInRadius(x1, z1,radius, textureName)
 {
 	for (var xx = x1-radius;xx <= x1 + radius; xx++)
 		for (var zz = z1-radius;zz <= z1 + radius; zz++)
 			if (xx !== x1 || zz !== z1)
 				if (xx >= 0 && xx < mapSize)
 					if (zz >= 0 && zz < mapSize)
 					{
 						if (typeof(textureName) != "number")
 						{
 							for (var i in textureName)
 								if ( g_Map.getTexture(xx,zz) == textureName[i])
 									return true;
 						} else {
 							if ( g_Map.getTexture(xx,zz) == textureName)
 								return true;
 						}
 					}
 	return false;
 }
Index: ps/trunk/binaries/data/mods/public/maps/random/flood.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/flood.js	(revision 19285)
+++ ps/trunk/binaries/data/mods/public/maps/random/flood.js	(revision 19286)
@@ -1,410 +1,410 @@
 RMS.LoadLibrary("rmgen");
 
 let random_terrain = randomizeBiome([g_BiomeSavanna]);
 
 const tMainTerrain = rBiomeT1();
 const tForestFloor1 = rBiomeT2();
 const tForestFloor2 = rBiomeT3();
 const tCliff = rBiomeT4();
 const tTier1Terrain = rBiomeT5();
 const tTier2Terrain = rBiomeT6();
 const tTier3Terrain = rBiomeT7();
 const tRoad = rBiomeT10();
 const tRoadWild = rBiomeT11();
 const tTier4Terrain = rBiomeT12();
 const tShore = rBiomeT14();
 const tWater = rBiomeT15();
 let tHill = rBiomeT8();
 let tDirt = rBiomeT9();
 
 if (random_terrain == g_BiomeTemperate)
 {
 	tDirt = ["medit_shrubs_a", "grass_field"];
 	tHill = ["grass_field", "peat_temp"];
 }
 
 // Gaia entities
 const oTree1 = rBiomeE1();
 const oTree2 = rBiomeE2();
 const oTree3 = rBiomeE3();
 const oTree4 = rBiomeE4();
 const oTree5 = rBiomeE5();
 const oFruitBush = rBiomeE6();
 const oMainHuntableAnimal = rBiomeE8();
 const oFish = rBiomeE9();
 const oSecondaryHuntableAnimal = rBiomeE10();
 const oStoneLarge = rBiomeE11();
 const oMetalLarge = rBiomeE13();
 
 // Decorative props
 const aGrass = rBiomeA1();
 const aGrassShort = rBiomeA2();
 const aRockLarge = rBiomeA5();
 const aRockMedium = rBiomeA6();
 const aBushMedium = rBiomeA7();
 const aBushSmall = rBiomeA8();
 
 const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
 const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
 
 log("Initializing map...");
 InitMap();
 
 const radius = scaleByMapSize(15, 25);
 const elevation = 2;
 const shoreRadius = 6;
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 const mapArea = mapSize * mapSize;
 const centerOfMap = mapSize / 2;
 
 // Create tile classes
 let clPlayer = createTileClass();
 let clHill = createTileClass();
 let clMountain = createTileClass();
 let clForest = createTileClass();
 let clWater = createTileClass();
 let clDirt = createTileClass();
 let clRock = createTileClass();
 let clMetal = createTileClass();
 let clFood = createTileClass();
 let clBaseResource = createTileClass();
 
 for (let ix = 0; ix < mapSize; ++ix)
 	for (let iz = 0; iz < mapSize; ++iz)
 		placeTerrain(ix, iz, tWater);
 
 // Randomize player order
 let playerIDs = [];
 for (let i = 0; i < numPlayers; ++i)
 	playerIDs.push(i+1);
 playerIDs = sortPlayers(playerIDs);
 
 // Place players
 let playerX = [];
 let playerZ = [];
 let playerAngle = [];
 
 let startAngle = randFloat(0, TWO_PI);
 for (let i = 0; i < numPlayers; ++i)
 {
 	playerAngle[i] = startAngle + i * TWO_PI/numPlayers;
 	playerX[i] = 0.5 + 0.38 * cos(playerAngle[i]);
 	playerZ[i] = 0.5 + 0.38 * sin(playerAngle[i]);
 }
 
 let fx = fractionToTiles(0.5);
 let fz = fractionToTiles(0.5);
 let ix = round(fx);
 let iz = round(fz);
 
 // Create the water
 let placer = new ClumpPlacer(mapArea * 1, 1, 1, 1, ix, iz);
 let terrainPainter = new LayeredPainter(
     [tWater, tWater, tShore], // terrains
     [1, 4] // widths
 );
 let elevationPainter = new SmoothElevationPainter(
    ELEVATION_SET,      // type
    getMapBaseHeight(), // elevation
    2                   // blend radius
 );
 createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 5));
 
 for (let i = 0; i < numPlayers; ++i)
 {
 	let id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	// Get the x and z in tiles
 	let fx = fractionToTiles(playerX[i]);
 	let fz = fractionToTiles(playerZ[i]);
 	let ix = round(fx);
 	let iz = round(fz);
 
 	let hillSize = PI * radius * radius * 2;
 
 	// Create the hill
 	let placer = new ClumpPlacer(hillSize, 0.80, 0.1, 10, ix, iz);
 	let terrainPainter = new LayeredPainter(
 		[tShore, tMainTerrain],	// terrains
 		[shoreRadius] // widths
 	);
 	let elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		elevation,				// elevation
 		shoreRadius				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clHill)], null);
 
 	// Mark a small area around the player's starting coördinates with the clPlayer class
 	addToClass(ix, iz, clPlayer);
 	addToClass(ix + 5, iz, clPlayer);
 	addToClass(ix, iz + 5, clPlayer);
 	addToClass(ix - 5, iz, clPlayer);
 	addToClass(ix, iz - 5, clPlayer);
 
 	placeCivDefaultEntities(fx, fz, id, { "iberWall": false });
 
 	// Create the city patch
 	let cityRadius = radius/3;
 	placer = new ClumpPlacer(PI * cityRadius * cityRadius, 0.6, 0.3, 10, ix, iz);
 	let painter = new LayeredPainter([tRoadWild, tRoad], [1]);
 	createArea(placer, painter, null);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// Create berry bushes
 	let bbAngle = randFloat(0, TWO_PI);
 	let bbDist = 12;
 	let bbX = round(fx + bbDist * cos(bbAngle));
 	let bbZ = round(fz + bbDist * sin(bbAngle));
 	let group = new SimpleGroup(
 		[new SimpleObject(oFruitBush, 5, 5, 0, 3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// Create metal mine
 	let mAngle = bbAngle;
 	while (abs(mAngle - bbAngle) < PI/3)
 		mAngle = randFloat(0, TWO_PI);
 
 	let mDist = 12;
 	let mX = round(fx + mDist * cos(mAngle));
 	let mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1, 1, 0, 0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// Create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1, 1, 0, 2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// Create starting trees, should avoid mines and bushes
 	let tries = 50;
 	let tDist = 16;
 	let num = 50;
 	for (let x = 0; x < tries; ++x)
 	{
 		let tAngle = randFloat(0, TWO_PI);
 		let tX = round(fx + tDist * cos(tAngle));
 		let tZ = round(fz + tDist * sin(tAngle));
 		group = new SimpleGroup(
 			[new SimpleObject(oTree2, num, num, 0, 7)],
 			true, clBaseResource, tX, tZ
 		);
 		if (createObjectGroup(group, 0, avoidClasses(clBaseResource, 5)))
 			break;
 	}
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 
 RMS.SetProgress(40);
 
 // Create central island
 placer = new ChainPlacer(floor(scaleByMapSize(6, 6)), floor(scaleByMapSize(10, 15)), floor(scaleByMapSize(200, 300)), 1, centerOfMap, centerOfMap, 0, [floor(mapSize * 0.01)]);
 terrainPainter = new LayeredPainter(
 	[tShore, tMainTerrain], // terrains
 	[shoreRadius, 100]      // widths
 );
 elevationPainter = new SmoothElevationPainter(
 	ELEVATION_SET, // type
 	elevation,     // elevation
 	shoreRadius    // blend radius
 );
 createArea(placer, [terrainPainter, elevationPainter, paintClass(clHill)], avoidClasses(clPlayer, 40));
 
 let randMountains = 20 + randInt(15);
 for (let m = 0; m < randMountains; ++m)
 {
 	let randX = randInt(mapSize);
 	let randY = randInt(mapSize);
 	let placer = new ChainPlacer(floor(scaleByMapSize(7, 7)), floor(scaleByMapSize(15, 15)), floor(scaleByMapSize(15, 20)), 1, randX, randY, 0, [floor(mapSize * 0.01)]);
 	let elevRand = 6 + randInt(15);
 	let terrainPainter = new LayeredPainter(
 		[tDirt, tHill],        // terrains
 		[floor(elevRand / 3), 40]       // widths
 	);
 	let elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,      // type
 		elevRand,           // elevation
 		floor(elevRand / 3)	// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clHill)], [avoidClasses(clBaseResource, 2, clPlayer, 40), stayClasses(clHill, 6)]);
 }
 
 randMountains = 8 + randInt(10);
 for (let m = 0; m < randMountains; ++m)
 {
 	let randX = randInt(mapSize);
 	let randY = randInt(mapSize);
 	let placer = new ChainPlacer(floor(scaleByMapSize(5, 5)), floor(scaleByMapSize(8, 8)), floor(scaleByMapSize(15, 20)), 1, randX, randY, 0, [floor(mapSize * 0.01)]);
 	let elevRand = 15 + randInt(15);
 	let terrainPainter = new LayeredPainter(
 		[tCliff, tForestFloor2],        // terrains
 		[floor(elevRand / 3), 40]       // widths
 	);
 	let elevationPainter = new SmoothElevationPainter(
 		ELEVATION_MODIFY,   // type
 		elevRand,           // elevation
 		floor(elevRand / 3) // blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clMountain)], [avoidClasses(clBaseResource, 2, clPlayer, 40), stayClasses(clHill, 6)]);
 }
 
 // Create center bounty
 let group = new SimpleGroup(
 	[new SimpleObject(oMetalLarge, 3, 6, 25, floor(mapSize * 0.25))],
 	true, clBaseResource, centerOfMap, centerOfMap
 );
 createObjectGroup(group, 0, [avoidClasses(clBaseResource, 20, clPlayer, 40, clMountain, 4), stayClasses(clHill, 10)]);
 group = new SimpleGroup(
 	[new SimpleObject(oStoneLarge, 3, 6, 25, floor(mapSize * 0.25))],
 	true, clBaseResource, centerOfMap, centerOfMap
 );
 createObjectGroup(group, 0, [avoidClasses(clBaseResource, 20, clPlayer, 40, clMountain, 4), stayClasses(clHill, 10)]);
 group = new SimpleGroup(
 	[new SimpleObject(oMainHuntableAnimal, floor(6 * numPlayers), floor(6 * numPlayers), 2, floor(mapSize * 0.1))],
 	true, clBaseResource, centerOfMap, centerOfMap
 );
 createObjectGroup(group, 0, [avoidClasses(clBaseResource, 2, clMountain, 4, clPlayer, 40, clWater, 2), stayClasses(clHill, 10)]);
 
 log("Creating fish...");
 group = new SimpleGroup(
 	[new SimpleObject(oFish, 2, 3, 0, 2)],
 	true, clFood
 );
 createObjectGroups(group, 0,
 	avoidClasses(clHill, 10, clFood, 20),
 	10 * numPlayers, 60
 );
 
 createForests(
 	[tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
 	[avoidClasses(clPlayer, 25, clForest, 10, clBaseResource, 3, clMetal, 6, clRock, 3, clMountain, 2), stayClasses(clHill, 6)],
 	clForest,
 	0.7,
 	random_terrain
 );
 
 log("Creating straggeler trees...");
 let types = [oTree1, oTree2, oTree4, oTree3];
 createStragglerTrees(types, [avoidClasses(clBaseResource, 2, clMetal, 6, clRock, 3, clMountain, 2, clPlayer, 25), stayClasses(clHill, 6)]);
 
 RMS.SetProgress(65);
 
 log("Creating dirt patches...");
 let sizes = [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)];
 let numb = random_terrain == g_BiomeSavanna ? 3 : 1;
 
 for (let i = 0; i < sizes.length; ++i)
 {
 	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
 	let painter = new LayeredPainter(
 		[[tMainTerrain, tTier1Terrain], [tTier1Terrain, tTier2Terrain], [tTier2Terrain, tTier3Terrain]], // terrains
 		[1, 1] // widths
 	);
 	createAreas(
 		placer,
 		[painter, paintClass(clDirt)],
 		avoidClasses(clForest, 0, clMountain, 0, clDirt, 5, clPlayer, 10),
 		numb * scaleByMapSize(15, 45)
 	);
 }
 
 log("Painting shorelines...");
 paintTerrainBasedOnHeight(1, 2, 0, tMainTerrain);
 paintTerrainBasedOnHeight(getMapBaseHeight(), 1, 3, tTier1Terrain);
 
 log("Creating grass patches...");
 sizes = [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)];
 for (let i = 0; i < sizes.length; ++i)
 {
 	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
 	let painter = new TerrainPainter(tTier4Terrain);
 	createAreas(
 		placer,
 		painter,
 		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)]
 );
 
 RMS.SetProgress(75);
 
 createFood(
 	[
 		[new SimpleObject(oFruitBush, 5, 7, 0, 4)]
 	],
 	[3 * numPlayers],
 	[avoidClasses(clForest, 0, clPlayer, 15, clMountain, 1, clFood, 4, clRock, 6, clMetal, 6), stayClasses(clHill, 2)]
 );
 
 RMS.SetProgress(85);
 
 log("Creating more straggeler trees...");
 createStragglerTrees(types, avoidClasses(clWater, 5, clForest, 7, clMountain, 1, clPlayer, 30, clMetal, 6, clRock, 3));
 
 log("Creating decoration...");
 let planetm = random_terrain == g_BiomeTropic ? 8 : 1;
 createDecoration
 (
 	[
 		[new SimpleObject(aRockMedium, 1, 3, 0, 1)],
 		[new SimpleObject(aRockLarge, 1, 2, 0, 1), new SimpleObject(aRockMedium, 1, 3, 0, 2)],
 		[new SimpleObject(aGrassShort, 2, 15, 0, 1, -PI/8, PI/8)],
 		[new SimpleObject(aGrass, 2, 10, 0, 1.8, -PI/8, PI/8), new SimpleObject(aGrassShort, 3, 10, 1.2, 2.5, -PI/8, PI/8)],
 		[new SimpleObject(aBushMedium, 1, 5, 0, 2), new SimpleObject(aBushSmall, 2, 4, 0, 2)]
 	],
 	[
 		scaleByMapSize(16, 262),
 		scaleByMapSize(8, 131),
 		planetm * scaleByMapSize(13, 200),
 		planetm * scaleByMapSize(13, 200),
 		planetm * scaleByMapSize(13, 200)
 	],
 	avoidClasses(clForest, 2, clPlayer, 20, clMountain, 5, clFood, 1, clBaseResource, 2)
 );
 
 log("Creating water forests...");
 createForests(
 	[tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
 	avoidClasses(clPlayer, 30, clHill, 10, clFood, 5),
 	clForest,
 	0.1,
 	random_terrain
 );
 
 log("Creating small grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aGrassShort, 1, 2, 0, 1, -PI / 8, PI / 8)]
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clMountain, 2, clPlayer, 2, clDirt, 0), stayClasses(clHill, 8)],
 	planetm * scaleByMapSize(13, 200)
 );
 
-setSkySet(shuffleArray(["cloudless", "cumulus", "overcast"])[0]);
+setSkySet(pickRandom(["cloudless", "cumulus", "overcast"]));
 setWaterMurkiness(0.4);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/island_stronghold.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/island_stronghold.js	(revision 19285)
+++ ps/trunk/binaries/data/mods/public/maps/random/island_stronghold.js	(revision 19286)
@@ -1,562 +1,561 @@
 /**
  * Returns starting position in tile coordinates for the given player.
  */
 function getPlayerTileCoordinates(playerIdx, teamIdx, fractionX, fractionZ)
 {
 	let playerAngle = startAngle + (playerIdx+1) * TWO_PI / teams[teamIdx].length;
 
 	let fx = fractionToTiles(fractionX + 0.05 * cos(playerAngle));
 	let fz = fractionToTiles(fractionZ + 0.05 * sin(playerAngle));
 
 	return [playerAngle, fx, fz, round(fx), round(fz)];
 }
 
 RMS.LoadLibrary("rmgen");
 RMS.LoadLibrary("heightmap");
 
 const g_InitialMines = 1;
 const g_InitialMineDistance = 14;
 const g_InitialTrees = 50;
 
 let random_terrain = randomizeBiome([g_BiomeSavanna]);
 
 const tMainTerrain = rBiomeT1();
 const tForestFloor1 = rBiomeT2();
 const tForestFloor2 = rBiomeT3();
 const tCliff = rBiomeT4();
 const tTier1Terrain = rBiomeT5();
 const tTier2Terrain = rBiomeT6();
 const tTier3Terrain = rBiomeT7();
 const tHill = rBiomeT8();
 const tTier4Terrain = rBiomeT12();
 const tShore = rBiomeT14();
 const tWater = rBiomeT15();
 
 // gaia entities
 const oTree1 = rBiomeE1();
 const oTree2 = rBiomeE2();
 const oTree3 = rBiomeE3();
 const oTree4 = rBiomeE4();
 const oTree5 = rBiomeE5();
 const oFruitBush = rBiomeE6();
 const oMainHuntableAnimal = rBiomeE8();
 const oFish = rBiomeE9();
 const oSecondaryHuntableAnimal = rBiomeE10();
 const oStoneLarge = rBiomeE11();
 const oStoneSmall = rBiomeE12();
 const oMetalLarge = rBiomeE13();
 const oWhale = "gaia/fauna_whale_humpback";
 const oShipwreck = "other/special_treasure_shipwreck";
 const oShipDebris = "other/special_treasure_shipwreck_debris";
 const oObelisk = "other/obelisk";
 
 // decorative props
 const aGrass = rBiomeA1();
 const aGrassShort = rBiomeA2();
 const aRockLarge = rBiomeA5();
 const aRockMedium = rBiomeA6();
 
 const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
 const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
 
 log("Initializing map...");
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 
 // create tile classes
 let clPlayer = createTileClass();
 let clHill = createTileClass();
 let clForest = createTileClass();
 let clDirt = createTileClass();
 let clRock = createTileClass();
 let clMetal = createTileClass();
 let clFood = createTileClass();
 let clBaseResource = createTileClass();
 let clLand = createTileClass();
 
 for (let ix = 0; ix < mapSize; ++ix)
 	for (let iz = 0; iz < mapSize; ++iz)
 		placeTerrain(ix, iz, tWater);
 
 // some constants
 let radius = scaleByMapSize(15, 25);
 
 let fx = fractionToTiles(0.5);
 let fz = fractionToTiles(0.5);
 
 let startAngle = randFloat(0, TWO_PI);
 
 // Group players by team
 let teams = [];
 for (let i = 0; i < numPlayers; ++i)
 {
 	let team = getPlayerTeam(i);
 	if (team == -1)
 		continue;
 
 	if (!teams[team])
 		teams[team] = [];
 
 	teams[team].push(i+1);
 }
 
 // Players without a team get a custom index
 for (let i = 0; i < numPlayers; ++i)
 {
 	let team = getPlayerTeam(i);
 	if (team != -1)
 		continue;
 
 	let unusedIndex = teams.findIndex(team => !team);
 
 	if (unusedIndex != -1)
 		teams[unusedIndex] = [i+1];
 	else
 		teams.push([i+1]);
 }
 
 // Get number of used team IDs
 let numTeams = teams.filter(team => team).length;
 
 RMS.SetProgress(10);
 
 let shoreRadius = 6;
 let elevation = 3;
 let teamNo = 0;
 
 for (let i = 0; i < teams.length; ++i)
 {
 	if (!teams[i])
 		continue;
 
 	++teamNo;
 	let teamAngle = startAngle + teamNo*TWO_PI/numTeams;
 	let fractionX = 0.5 + 0.3 * cos(teamAngle);
 	let fractionZ = 0.5 + 0.3 * sin(teamAngle);
 	let teamX = fractionToTiles(fractionX);
 	let teamZ = fractionToTiles(fractionZ);
 
 	log("Creating island and starting entities for team " + i);
 	for (let p = 0; p < teams[i].length; ++p)
 	{
 		let [playerAngle, fx, fz, ix, iz] = getPlayerTileCoordinates(p, i, fractionX, fractionZ);
 
 		// mark a small area around the player's starting coordinates with the clPlayer class
 		addToClass(ix, iz, clPlayer);
 		addToClass(ix+5, iz, clPlayer);
 		addToClass(ix, iz+5, clPlayer);
 		addToClass(ix-5, iz, clPlayer);
 		addToClass(ix, iz-5, clPlayer);
 
 		// create an island
 		let placer = new ChainPlacer(2, floor(scaleByMapSize(5, 11)), floor(scaleByMapSize(60, 250)), 1, ix, iz, 0, [floor(mapSize * 0.01)]);
 		let terrainPainter = new LayeredPainter(
 			[tMainTerrain, tMainTerrain, tMainTerrain],       // terrains
 			[1, shoreRadius]     // widths
 		);
 		let elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,          // type
 			elevation,              // elevation
 			shoreRadius               // blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 		// create starting units
 		placeCivDefaultEntities(fx, fz, teams[i][p], { "iberWall": false });
 	}
 
 	log("Create initial mines for team " + i);
 	for (let p = 0; p < teams[i].length; ++p)
 	{
 		let [playerAngle, fx, fz, ix, iz] = getPlayerTileCoordinates(p, i, fractionX, fractionZ);
 		let mAngle = randFloat(playerAngle - PI / teams[i].length, playerAngle + PI / teams[i].length);
 
 		// Metal
 		let mX = round(fx + g_InitialMineDistance * cos(mAngle));
 		let mZ = round(fz + g_InitialMineDistance * sin(mAngle));
 		let group = new SimpleGroup(
 			[new SimpleObject(oMetalLarge, g_InitialMines, g_InitialMines, 0, 4)],
 			true, clBaseResource, mX, mZ
 		);
 		createObjectGroup(group, 0, [avoidClasses(clBaseResource, 2, clPlayer, 4), stayClasses(clLand, 2)]);
 
 		// Stone
 		let sX = round(fx + g_InitialMineDistance * cos(mAngle + PI/4));
 		let sZ = round(fz + g_InitialMineDistance * sin(mAngle + PI/4));
 		group = new SimpleGroup(
 			[new SimpleObject(oStoneLarge, g_InitialMines, g_InitialMines, 0, 4)],
 			true, clBaseResource, sX, sZ
 		);
 		createObjectGroup(group, 0, [avoidClasses(clBaseResource, 2, clPlayer, 4), stayClasses(clLand, 2)]);
 	}
 
 	log("Place initial trees and animals for team " + i);
 	for (let p = 0; p < teams[i].length; ++p)
 	{
 		let [playerAngle, fx, fz, ix, iz] = getPlayerTileCoordinates(p, i, fractionX, fractionZ);
 
 		placeDefaultChicken(fx, fz, clBaseResource, [stayClasses(clLand, 5)]);
 
 		// create initial berry bushes
 		let bbAngle = randFloat(PI, PI*1.5);
 		let bbDist = 10;
 		let bbX = round(fx + bbDist * cos(bbAngle));
 		let bbZ = round(fz + bbDist * sin(bbAngle));
 		let group = new SimpleGroup(
 			[new SimpleObject(oFruitBush, 5, 5, 0, 3)],
 			true, clBaseResource, bbX, bbZ
 		);
 		createObjectGroup(group, 0, [avoidClasses(clBaseResource, 4, clPlayer, 4), stayClasses(clLand, 5)]);
 
 		// create initial trees
 		let tries = 10;
 		let tDist = 16;
 		for (let x = 0; x < tries; ++x)
 		{
 			let tAngle = randFloat(playerAngle - TWO_PI/teams[i].length,
 			                       playerAngle + TWO_PI/teams[i].length);
 
 			let tX = round(fx + tDist * cos(tAngle));
 			let tZ = round(fz + tDist * sin(tAngle));
 
 			group = new SimpleGroup(
 				[new SimpleObject(oTree2, g_InitialTrees, g_InitialTrees, 0, 7)],
 				true, clBaseResource, tX, tZ
 			);
 			if (createObjectGroup(group, 0, [avoidClasses(clBaseResource, 4, clPlayer, 4), stayClasses(clLand, 4)]))
 				break;
 		}
 
 		// create huntable animals
 		group = new SimpleGroup(
 			[new SimpleObject(oMainHuntableAnimal, 2 * numPlayers / numTeams, 2 * numPlayers / numTeams, 0, floor(mapSize * 0.2))],
 			true, clBaseResource, teamX, teamZ
 		);
 		createObjectGroup(group, 0, [avoidClasses(clBaseResource, 2, clHill, 1, clPlayer, 10), stayClasses(clLand, 5)]);
 		group = new SimpleGroup(
 			[new SimpleObject(oSecondaryHuntableAnimal, 4 * numPlayers / numTeams, 4 * numPlayers / numTeams, 0, floor(mapSize * 0.2))],
 			true, clBaseResource, teamX, teamZ
 		);
 		createObjectGroup(group, 0, [avoidClasses(clBaseResource, 2, clHill, 1, clPlayer, 10), stayClasses(clLand, 5)]);
 	}
 }
 
 RMS.SetProgress(40);
 
 log("Creating expansion islands...");
 let landAreas = [];
 let playerConstraint = new AvoidTileClassConstraint(clPlayer, floor(scaleByMapSize(12, 16)));
 let landConstraint = new AvoidTileClassConstraint(clLand, floor(scaleByMapSize(12, 16)));
 
 for (let x = 0; x < mapSize; ++x)
 	for (let z = 0; z < mapSize; ++z)
 		if (playerConstraint.allows(x, z) && landConstraint.allows(x, z))
 			landAreas.push([x, z]);
 
 log("Creating big islands...");
 let chosenPoint;
 let landAreaLen;
 let numIslands = scaleByMapSize(4, 14);
 for (let i = 0; i < numIslands; ++i)
 {
 	landAreaLen = landAreas.length;
 	if (!landAreaLen)
 		break;
 
 	chosenPoint = landAreas[randInt(landAreaLen)];
 
 	// create big islands
 	let placer = new ChainPlacer(floor(scaleByMapSize(4, 8)), floor(scaleByMapSize(8, 14)), floor(scaleByMapSize(25, 60)), 0.07, chosenPoint[0], chosenPoint[1], scaleByMapSize(30, 70));
 	let terrainPainter = new LayeredPainter(
 		[tMainTerrain, tMainTerrain],		// terrains
 		[2]								// widths
 	);
 
 	let elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 6);
 	let newIsland = createAreas(
 		placer,
 		[terrainPainter, elevationPainter, paintClass(clLand)],
 		avoidClasses(clLand, 3, clPlayer, 3),
 		1, 1
 	);
 
 	if (!newIsland || !newIsland.length)
 		continue;
 
 	let n = 0;
 	for (let j = 0; j < landAreaLen; ++j)
 	{
 		let x = landAreas[j][0];
 		let z = landAreas[j][1];
 
 		if (playerConstraint.allows(x, z) && landConstraint.allows(x, z))
 			landAreas[n++] = landAreas[j];
 	}
 	landAreas.length = n;
 }
 
 playerConstraint = new AvoidTileClassConstraint(clPlayer, floor(scaleByMapSize(9, 12)));
 landConstraint = new AvoidTileClassConstraint(clLand, floor(scaleByMapSize(9, 12)));
 
 log("Creating small islands...");
 numIslands = scaleByMapSize(6, 18) * scaleByMapSize(1, 3);
 for (let i = 0; i < numIslands; ++i)
 {
 	landAreaLen = landAreas.length;
 	if (!landAreaLen)
 		break;
 
 	chosenPoint = landAreas[randInt(0, landAreaLen)];
 
 	let placer = new ChainPlacer(floor(scaleByMapSize(4, 7)), floor(scaleByMapSize(7, 10)), floor(scaleByMapSize(16, 40)), 0.07, chosenPoint[0], chosenPoint[1], scaleByMapSize(22, 40));
 	let terrainPainter = new LayeredPainter(
 		[tMainTerrain, tMainTerrain],		// terrains
 		[2]								// widths
 	);
 
 	let elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 6);
 	let newIsland = createAreas(
 		placer,
 		[terrainPainter, elevationPainter, paintClass(clLand)],
 		avoidClasses(clLand, 3, clPlayer, 3),
 		1, 1
 	);
 
 	if (newIsland === undefined)
 		continue;
 
 	let temp = [];
 	for (let j = 0; j < landAreaLen; ++j)
 	{
 		let x = landAreas[j][0];
 		let z = landAreas[j][1];
 
 		if (playerConstraint.allows(x, z) && landConstraint.allows(x, z))
 			temp.push([x, z]);
 	}
 	landAreas = temp;
 }
 
 RMS.SetProgress(70);
 
 log("Smoothing heightmap...");
 for (let i = 0; i < 5; ++i)
 	globalSmoothHeightmap();
 
 // repaint clLand to compensate for smoothing
 unPaintTileClassBasedOnHeight(-10, 10, 3, clLand);
 paintTileClassBasedOnHeight(0, 5, 3, clLand);
 
 RMS.SetProgress(85);
 
 createBumps();
 
 createMines(
 [
 	[new SimpleObject(oMetalLarge, 1, 1, 3, (numPlayers * 2) + 1)]
 ],
 [avoidClasses(clForest, 1, clPlayer, 40, clRock, 20, clHill, 5), stayClasses(clLand, 4)],
 clMetal
 );
 
 createMines(
 [
 	[new SimpleObject(oStoneLarge, 1, 1, 3, (numPlayers * 2) + 1)], [new SimpleObject(oStoneSmall, 2, 2, 2, (numPlayers * 2) + 1)]
 ],
 [avoidClasses(clForest, 1, clPlayer, 40, clMetal, 20, clHill, 5), stayClasses(clLand, 4)],
 clRock
 );
 
 createForests(
  [tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
  [avoidClasses(clPlayer, 10, clForest, 20, clHill, 10, clBaseResource, 5, clRock, 6, clMetal, 6), stayClasses(clLand, 3)],
  clForest,
  1.0,
  random_terrain
 );
 
 log("Creating hills...");
 let placer = new ChainPlacer(1, floor(scaleByMapSize(4, 6)), floor(scaleByMapSize(16, 40)), 0.5);
 let painter = new LayeredPainter(
 	[tCliff, tHill],		// terrains
 	[2]								// widths
 );
 let elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 18, 2);
 createAreas(
 	placer,
 	[painter, elevationPainter, paintClass(clHill)],
 	[avoidClasses(clBaseResource, 20, clHill, 15, clRock, 6, clMetal, 6), stayClasses(clLand, 0)],
 	scaleByMapSize(4, 13)
 );
 for (let i = 0; i < 3; ++i)
 	globalSmoothHeightmap();
 
 createStragglerTrees(
 		[oTree1, oTree2, oTree4, oTree3],
 		[avoidClasses(clForest, 10, clPlayer, 20, clMetal, 6, clRock, 6, clHill, 1),
 		 stayClasses(clLand, 4)]
 );
 
 createFood(
 	[
 		[new SimpleObject(oMainHuntableAnimal, 5, 7, 0, 4)],
 		[new SimpleObject(oSecondaryHuntableAnimal, 2, 3, 0, 2)]
 	],
 	[3 * numPlayers, 3 * numPlayers],
 	[avoidClasses(clForest, 0, clPlayer, 20, clHill, 1, clRock, 6, clMetal, 6), stayClasses(clLand, 2)]
 );
 
 createFood(
 	[
 		[new SimpleObject(oFruitBush, 5, 7, 0, 4)]
 	],
 	[3 * numPlayers],
 	[avoidClasses(clForest, 0, clPlayer, 15, clHill, 1, clFood, 4, clRock, 6, clMetal, 6), stayClasses(clLand, 2)]
 );
 
 if (random_terrain == g_BiomeDesert)
 {
 	log("Creating obelisks");
 	let group = new SimpleGroup(
 		[new SimpleObject(oObelisk, 1, 1, 0, 1)],
 		true
 	);
 	createObjectGroups(
 		group, 0,
 		[avoidClasses(clBaseResource, 0, clHill, 0, clRock, 0, clMetal, 0, clFood, 0), stayClasses(clLand, 1)],
 		scaleByMapSize(3, 8), 1000
 	);
 }
 
 log("Creating dirt patches...");
 let sizes = [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)];
 let numb = random_terrain == g_BiomeSavanna ? 3 : 1;
 
 for (let i = 0; i < sizes.length; ++i)
 {
 	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
 	painter = new LayeredPainter(
 		[[tMainTerrain,tTier1Terrain], [tTier1Terrain,tTier2Terrain], [tTier2Terrain,tTier3Terrain]],		// terrains
 		[1, 1]															// widths
 	);
 	createAreas(
 		placer,
 		[painter, paintClass(clDirt)],
 		[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 0), stayClasses(clLand, 4)],
 		numb*scaleByMapSize(15, 45)
 	);
 }
 
 log("Creating grass patches...");
 sizes = [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)];
 for (let i = 0; i < sizes.length; ++i)
 {
 	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
 	painter = new TerrainPainter(tTier4Terrain);
 	createAreas(
 		placer,
 		painter,
 		[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 0), stayClasses(clLand, 4)],
 		numb * scaleByMapSize(15, 45)
 	);
 }
 
 log("Creating small decorative rocks...");
 let group = new SimpleGroup(
 	[new SimpleObject(aRockMedium, 1, 3, 0, 1)],
 	true
 );
 createObjectGroups(
 	group, 0,
 	[avoidClasses(clForest, 0, clHill, 0), stayClasses(clLand, 2)],
 	scaleByMapSize(16, 262), 50
 );
 
 log("Creating large decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockLarge, 1, 2, 0, 1), new SimpleObject(aRockMedium, 1, 3, 0, 2)],
 	true
 );
 createObjectGroups(
 	group, 0,
 	[avoidClasses(clForest, 0, clHill, 0), stayClasses(clLand, 2)],
 	scaleByMapSize(8, 131), 50
 );
 
 log("Creating fish...");
 group = new SimpleGroup(
 	[new SimpleObject(oFish, 2, 3, 0, 2)],
 	true, clFood
 );
 createObjectGroups(group, 0,
 	avoidClasses(clLand, 4, clFood, 20),
 	25 * numPlayers, 60
 );
 
 log("Creating Whales...");
 group = new SimpleGroup(
 	[new SimpleObject(oWhale, 1, 1, 0, 3)],
 	true, clFood
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clLand, 4),avoidClasses(clFood, 8)],
 	scaleByMapSize(5, 20), 100
 );
 
 log("Creating shipwrecks...");
 group = new SimpleGroup(
 	[new SimpleObject(oShipwreck, 1, 1, 0, 1)],
 	true, clFood
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clLand, 4),avoidClasses(clFood, 8)],
 	scaleByMapSize(12, 16), 100
 );
 
 log("Creating shipwreck debris...");
 group = new SimpleGroup(
 	[new SimpleObject(oShipDebris, 1, 1, 0, 1)],
 	true, clFood
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clLand, 4),avoidClasses(clFood, 8)],
 	scaleByMapSize(10, 20), 100
 );
 
 placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius, [stayClasses(clLand, 5)]);
 
 log("Creating small grass tufts...");
 let planetm = random_terrain == 7 ? 8 : 1;
 group = new SimpleGroup(
 	[new SimpleObject(aGrassShort, 1, 2, 0, 1, -PI / 8, PI / 8)]
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clHill, 2, clPlayer, 2, clDirt, 0), stayClasses(clLand, 3)],
 	planetm * scaleByMapSize(13, 200)
 );
 
 RMS.SetProgress(95);
 
 log("Creating large grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aGrass, 2, 4, 0, 1.8, -PI / 8, PI / 8), new SimpleObject(aGrassShort, 3, 6, 1.2,2.5, -PI / 8, PI / 8)]
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clHill, 2, clPlayer, 2, clDirt, 1, clForest, 0), stayClasses(clLand, 5)],
 	planetm * scaleByMapSize(13, 200)
 );
 
 paintTerrainBasedOnHeight(1, 2, 0, tShore);
 paintTerrainBasedOnHeight(getMapBaseHeight(), 1, 3, tWater);
 
-setSkySet(shuffleArray(["cloudless", "cumulus", "overcast"])[0]);
-
+setSkySet(pickRandom(["cloudless", "cumulus", "overcast"]));
 setSunRotation(randFloat(0, TWO_PI));
 setSunElevation(randFloat(PI/5, PI/3));
 setWaterWaviness(2);
 
 RMS.SetProgress(100);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/islands.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/islands.js	(revision 19285)
+++ ps/trunk/binaries/data/mods/public/maps/random/islands.js	(revision 19286)
@@ -1,579 +1,572 @@
 RMS.LoadLibrary("rmgen");
 
 TILE_CENTERED_HEIGHT_MAP = true;
 //random terrain textures
 var random_terrain = randomizeBiome();
 
 const tMainTerrain = rBiomeT1();
 const tForestFloor1 = rBiomeT2();
 const tForestFloor2 = rBiomeT3();
 const tCliff = rBiomeT4();
 const tTier1Terrain = rBiomeT5();
 const tTier2Terrain = rBiomeT6();
 const tTier3Terrain = rBiomeT7();
 const tHill = rBiomeT8();
 const tDirt = rBiomeT9();
 const tRoad = rBiomeT10();
 const tRoadWild = rBiomeT11();
 const tTier4Terrain = rBiomeT12();
 const tShoreBlend = rBiomeT13();
 const tShore = rBiomeT14();
 const tWater = rBiomeT15();
 
 // gaia entities
 const oTree1 = rBiomeE1();
 const oTree2 = rBiomeE2();
 const oTree3 = rBiomeE3();
 const oTree4 = rBiomeE4();
 const oTree5 = rBiomeE5();
 const oFruitBush = rBiomeE6();
 const oMainHuntableAnimal = rBiomeE8();
 const oFish = rBiomeE9();
 const oSecondaryHuntableAnimal = rBiomeE10();
 const oStoneLarge = rBiomeE11();
 const oStoneSmall = rBiomeE12();
 const oMetalLarge = rBiomeE13();
 const oWood = "gaia/special_treasure_wood";
 
 // decorative props
 const aGrass = rBiomeA1();
 const aGrassShort = rBiomeA2();
 const aReeds = rBiomeA3();
 const aLillies = rBiomeA4();
 const aRockLarge = rBiomeA5();
 const aRockMedium = rBiomeA6();
 const aBushMedium = rBiomeA7();
 const aBushSmall = rBiomeA8();
 
 const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
 const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
 
 log("Initializing map...");
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 const mapArea = mapSize*mapSize;
 
 // create tile classes
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clSettlement = createTileClass();
 var clLand = createTileClass();
 
 // randomize player order
 var playerIDs = [];
 for (var i = 0; i < numPlayers; i++)
 {
 	playerIDs.push(i+1);
 }
 playerIDs = sortPlayers(playerIDs);
 
 // place players
 var playerX = new Array(numPlayers);
 var playerZ = new Array(numPlayers);
 var playerAngle = new Array(numPlayers);
 
 var startAngle = randFloat(0, TWO_PI);
 for (var i = 0; i < numPlayers; i++)
 {
 	playerAngle[i] = startAngle + i*TWO_PI/numPlayers;
 	playerX[i] = 0.5 + 0.35*cos(playerAngle[i]);
 	playerZ[i] = 0.5 + 0.35*sin(playerAngle[i]);
 }
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	// some constants
 	var radius = scaleByMapSize(20,29);
 	var shoreRadius = 6;
 	var elevation = 3;
 
 	var hillSize = PI * radius * radius;
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 	// create the hill
 	var placer = new ClumpPlacer(hillSize, 0.80, 0.1, 10, ix, iz);
 	var terrainPainter = new LayeredPainter(
 		[tMainTerrain , tMainTerrain, tMainTerrain],		// terrains
 		[1, shoreRadius]		// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		elevation,				// elevation
 		shoreRadius				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clPlayer)], null);
 
 	// create starting units
 	placeCivDefaultEntities(fx, fz, id, { 'iberWall': 'towers' });
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oFruitBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create woods
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 13;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oWood, 14,14, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 	var hillSize = PI * radius * radius;
 	// create starting trees
 	var num = 5;
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(12, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oTree1, num, num, 0,3)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 
 	//create docks
 	var dockLocation = getTIPIADBON([ix, iz], [mapSize / 2, mapSize / 2], [-3 , 2.6], 0.5, 3);
 	if (dockLocation !== undefined)
 		placeObject(dockLocation[0], dockLocation[1], "structures/" + getCivCode(id-1) + "_dock", id, playerAngle[i] + PI);
 }
 
 var landAreas = [];
 var playerConstraint = new AvoidTileClassConstraint(clPlayer, floor(scaleByMapSize(12,16)));
 var landConstraint = new AvoidTileClassConstraint(clLand, floor(scaleByMapSize(12,16)));
 
 for (var x = 0; x < mapSize; ++x)
 	for (var z = 0; z < mapSize; ++z)
 		if (playerConstraint.allows(x, z) && landConstraint.allows(x, z))
 			landAreas.push([x, z]);
 
 var chosenPoint;
 var landAreaLen;
 
 log("Creating big islands...");
 var numIslands = scaleByMapSize(4, 14);
 for (var i = 0; i < numIslands; ++i)
 {
 	landAreaLen = landAreas.length;
 	if (!landAreaLen)
 		break;
 
 	chosenPoint = landAreas[randInt(landAreaLen)];
 
 	// create big islands
 	placer = new ChainPlacer(floor(scaleByMapSize(4, 8)), floor(scaleByMapSize(8, 14)), floor(scaleByMapSize(25, 60)), 0.07, chosenPoint[0], chosenPoint[1], scaleByMapSize(30,70));
 	//placer = new ClumpPlacer(floor(hillSize*randFloat(0.9,2.1)), 0.80, 0.1, 0.07, chosenPoint[0], chosenPoint[1]);
 	terrainPainter = new LayeredPainter(
 		[tMainTerrain, tMainTerrain],		// terrains
 		[2]								// widths
 	);
 	elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 6);
 	var newIsland = createAreas(
 		placer,
 		[terrainPainter, elevationPainter, paintClass(clLand)],
 		avoidClasses(clLand, 3, clPlayer, 3),
 		1, 1
 	);
 	if (newIsland && newIsland.length)
 	{
 		var n = 0;
 		for (var j = 0; j < landAreaLen; ++j)
 		{
 			var x = landAreas[j][0], z = landAreas[j][1];
 			if (playerConstraint.allows(x, z) && landConstraint.allows(x, z))
 				landAreas[n++] = landAreas[j];
 		}
 		landAreas.length = n;
 	}
 }
 
 playerConstraint = new AvoidTileClassConstraint(clPlayer, floor(scaleByMapSize(9,12)));
 landConstraint = new AvoidTileClassConstraint(clLand, floor(scaleByMapSize(9,12)));
 
 log("Creating small islands...");
 numIslands = scaleByMapSize(6, 18) * scaleByMapSize(1,3);
 for (var i = 0; i < numIslands; ++i)
 {
 	landAreaLen = landAreas.length;
 	if (!landAreaLen)
 		break;
 
 	chosenPoint = landAreas[randInt(0, landAreaLen)];
 
 	placer = new ChainPlacer(floor(scaleByMapSize(4, 7)), floor(scaleByMapSize(7, 10)), floor(scaleByMapSize(16, 40)), 0.07, chosenPoint[0], chosenPoint[1], scaleByMapSize(22,40));
 	terrainPainter = new LayeredPainter(
 		[tMainTerrain, tMainTerrain],		// terrains
 		[2]								// widths
 	);
 	elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 6);
 	createAreas(
 		placer,
 		[terrainPainter, elevationPainter, paintClass(clLand)],
 		avoidClasses(clLand, 3, clPlayer, 3),
 		1, 1
 	);
 	if (newIsland !== undefined)
 	{
 		var temp = [];
 		for (var j = 0; j < landAreaLen; ++j)
 		{
 			var x = landAreas[j][0], z = landAreas[j][1];
 			if (playerConstraint.allows(x, z) && landConstraint.allows(x, z))
 					temp.push([x, z]);
 		}
 		landAreas = temp;
 	}
 }
 paintTerrainBasedOnHeight(1, 3, 0, tShore);
 paintTerrainBasedOnHeight(-8, 1, 2, tWater);
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 	// create the city patch
 	var cityRadius = radius/3;
 	placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tRoadWild, tRoad], [1]);
 	createArea(placer, painter, null);
 }
 
 // create bumps
 log("Creating bumps...");
 placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1);
 painter = new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2);
 createAreas(
 	placer,
 	painter,
 	[avoidClasses(clPlayer, 0), stayClasses(clLand, 3)],
 	scaleByMapSize(20, 100)
 );
 
 // create hills
 log("Creating hills...");
 placer = new ChainPlacer(1, floor(scaleByMapSize(4, 6)), floor(scaleByMapSize(16, 40)), 0.5);
 terrainPainter = new LayeredPainter(
 	[tCliff, tHill],		// terrains
 	[2]								// widths
 );
 elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 18, 2);
 createAreas(
 	placer,
 	[terrainPainter, elevationPainter, paintClass(clHill)],
 	[avoidClasses(clPlayer, 2, clHill, 15), stayClasses(clLand, 0)],
 	scaleByMapSize(4, 13)
 );
 
 
 // calculate desired number of trees for map (based on size)
 if (random_terrain == g_BiomeSavanna)
 {
 	var MIN_TREES = 200;
 	var MAX_TREES = 1250;
 	var P_FOREST = 0;
 }
 else if (random_terrain == g_BiomeTropic)
 {
 	var MIN_TREES = 1000;
 	var MAX_TREES = 6000;
 	var P_FOREST = 0.52;
 }
 else
 {
 	var MIN_TREES = 500;
 	var MAX_TREES = 3000;
 	var P_FOREST = 0.7;
 }
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 var numForest = totalTrees * P_FOREST;
 var numStragglers = totalTrees * (1.0 - P_FOREST);
 
 // create forests
 log("Creating forests...");
 var types = [
 	[[tForestFloor2, tMainTerrain, pForest1], [tForestFloor2, pForest1]],
 	[[tForestFloor1, tMainTerrain, pForest2], [tForestFloor1, pForest2]]
 ];	// some variation
 
 if (random_terrain != g_BiomeSavanna)
 {
 	var size = numForest / (scaleByMapSize(3,6) * numPlayers);
 	var num = floor(size / types.length);
 	for (var i = 0; i < types.length; ++i)
 	{
 		placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), numForest / (num * floor(scaleByMapSize(2,5))), 0.5);
 		painter = new LayeredPainter(
 			types[i],		// terrains
 			[2]											// widths
 			);
 		createAreas(
 			placer,
 			[painter, paintClass(clForest)],
 			[avoidClasses(clPlayer, 0, clForest, 10, clHill, 0), stayClasses(clLand, 6)],
 			num
 		);
 	}
 }
 
 RMS.SetProgress(50);
 // create dirt patches
 log("Creating dirt patches...");
 var sizes = [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)];
 var numb = 1;
 if (random_terrain == g_BiomeSavanna)
 	numb = 3;
 for (var i = 0; i < sizes.length; i++)
 {
 	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
 	painter = new LayeredPainter(
 		[[tMainTerrain,tTier1Terrain],[tTier1Terrain,tTier2Terrain], [tTier2Terrain,tTier3Terrain]], 		// terrains
 		[1,1]															// widths
 	);
 	createAreas(
 		placer,
 		[painter, paintClass(clDirt)],
 		[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 0), stayClasses(clLand, 6)],
 		numb*scaleByMapSize(15, 45)
 	);
 }
 
 // create grass patches
 log("Creating grass patches...");
 var sizes = [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)];
 for (var i = 0; i < sizes.length; i++)
 {
 	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
 	painter = new TerrainPainter(tTier4Terrain);
 	createAreas(
 		placer,
 		painter,
 		[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 0), stayClasses(clLand, 6)],
 		numb*scaleByMapSize(15, 45)
 	);
 }
 RMS.SetProgress(55);
 
 
 log("Creating stone mines...");
 // create large stone quarries
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
 createObjectGroups(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 0, clRock, 10, clHill, 1), stayClasses(clLand, 5)],
 	scaleByMapSize(4,16), 100
 );
 
 // create small stone quarries
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroups(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 0, clRock, 10, clHill, 1), stayClasses(clLand, 5)],
 	scaleByMapSize(4,16), 100
 );
 
 log("Creating metal mines...");
 // create large metal quarries
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroups(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 0, clMetal, 10, clRock, 5, clHill, 1), stayClasses(clLand, 5)],
 	scaleByMapSize(4,16), 100
 );
 
 RMS.SetProgress(65);
 
 // create small decorative rocks
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockMedium, 1,3, 0,1)],
 	true
 );
 createObjectGroups(
 	group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 5)],
 	scaleByMapSize(16, 262), 50
 );
 
 
 // create large decorative rocks
 log("Creating large decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
 	true
 );
 createObjectGroups(
 	group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 5)],
 	scaleByMapSize(8, 131), 50
 );
 
 RMS.SetProgress(70);
 
 // create deer
 log("Creating deer...");
 group = new SimpleGroup(
 	[new SimpleObject(oMainHuntableAnimal, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 0, clHill, 1, clFood, 20), stayClasses(clLand, 5)],
 	3 * numPlayers, 50
 );
 
 RMS.SetProgress(75);
 
 // create sheep
 log("Creating sheep...");
 group = new SimpleGroup(
 	[new SimpleObject(oSecondaryHuntableAnimal, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 0, clHill, 1, clFood, 20), stayClasses(clLand, 5)],
 	3 * numPlayers, 50
 );
 
 // create fruit bush
 log("Creating fruit bush...");
 group = new SimpleGroup(
 	[new SimpleObject(oFruitBush, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 8, clHill, 1, clFood, 20), stayClasses(clLand, 5)],
 	randInt(1, 4) * numPlayers + 2, 50
 );
 
 // create fish
 log("Creating fish...");
 group = new SimpleGroup(
 	[new SimpleObject(oFish, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroups(group, 0,
 	avoidClasses(clLand, 4, clForest, 2, clPlayer, 2, clHill, 2, clFood, 20),
 	25 * numPlayers, 60
 );
 
 RMS.SetProgress(85);
 
 
 // create straggler trees
 log("Creating straggler trees...");
 var types = [oTree1, oTree2, oTree4, oTree3];	// some variation
 var num = floor(numStragglers / types.length);
 for (var i = 0; i < types.length; ++i)
 {
 	group = new SimpleGroup(
 		[new SimpleObject(types[i], 1,1, 0,3)],
 		true, clForest
 	);
 	createObjectGroups(group, 0,
 		[avoidClasses(clForest, 1, clHill, 1, clPlayer, 0, clMetal, 6, clRock, 6), stayClasses(clLand, 6)],
 		num
 	);
 }
 
 var planetm = 1;
 if (random_terrain == g_BiomeTropic)
 	planetm = 8;
 
 //create small grass tufts
 log("Creating small grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)]
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clHill, 2, clPlayer, 2, clDirt, 0), stayClasses(clLand, 6)],
 	planetm * scaleByMapSize(13, 200)
 );
 
 RMS.SetProgress(90);
 
 // create large grass tufts
 log("Creating large grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aGrass, 2,4, 0,1.8, -PI/8,PI/8), new SimpleObject(aGrassShort, 3,6, 1.2,2.5, -PI/8,PI/8)]
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clHill, 2, clPlayer, 2, clDirt, 1, clForest, 0), stayClasses(clLand, 5)],
 	planetm * scaleByMapSize(13, 200)
 );
 
 RMS.SetProgress(95);
 
 // create bushes
 log("Creating bushes...");
 group = new SimpleGroup(
 	[new SimpleObject(aBushMedium, 1,2, 0,2), new SimpleObject(aBushSmall, 2,4, 0,2)]
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clHill, 1, clPlayer, 1, clDirt, 1), stayClasses(clLand, 6)],
 	planetm * scaleByMapSize(13, 200), 50
 );
 
-random_terrain = randInt(1,3);
-if (random_terrain == 1)
-	setSkySet("cirrus");
-else if (random_terrain == 2)
-	setSkySet("cumulus");
-else if (random_terrain == 3)
-	setSkySet("sunny");
-
+setSkySet(pickRandom(["cirrus", "cumulus", "sunny"]));
 setSunRotation(randFloat(0, TWO_PI));
 setSunElevation(randFloat(PI/ 5, PI / 3));
 setWaterWaviness(2);
 
 // Export map data
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/migration.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/migration.js	(revision 19285)
+++ ps/trunk/binaries/data/mods/public/maps/random/migration.js	(revision 19286)
@@ -1,496 +1,489 @@
 RMS.LoadLibrary("rmgen");
 
 //random terrain textures
 var random_terrain = randomizeBiome();
 
 const tMainTerrain = rBiomeT1();
 const tForestFloor1 = rBiomeT2();
 const tForestFloor2 = rBiomeT3();
 const tCliff = rBiomeT4();
 const tTier1Terrain = rBiomeT5();
 const tTier2Terrain = rBiomeT6();
 const tTier3Terrain = rBiomeT7();
 const tHill = rBiomeT8();
 const tDirt = rBiomeT9();
 const tRoad = rBiomeT10();
 const tRoadWild = rBiomeT11();
 const tTier4Terrain = rBiomeT12();
 const tShoreBlend = rBiomeT13();
 const tShore = rBiomeT14();
 const tWater = rBiomeT15();
 
 // gaia entities
 const oTree1 = rBiomeE1();
 const oTree2 = rBiomeE2();
 const oTree3 = rBiomeE3();
 const oTree4 = rBiomeE4();
 const oTree5 = rBiomeE5();
 const oFruitBush = rBiomeE6();
 const oMainHuntableAnimal = rBiomeE8();
 const oFish = rBiomeE9();
 const oSecondaryHuntableAnimal = rBiomeE10();
 const oStoneLarge = rBiomeE11();
 const oStoneSmall = rBiomeE12();
 const oMetalLarge = rBiomeE13();
 const oWood = "gaia/special_treasure_wood";
 
 // decorative props
 const aGrass = rBiomeA1();
 const aGrassShort = rBiomeA2();
 const aReeds = rBiomeA3();
 const aLillies = rBiomeA4();
 const aRockLarge = rBiomeA5();
 const aRockMedium = rBiomeA6();
 const aBushMedium = rBiomeA7();
 const aBushSmall = rBiomeA8();
 
 const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
 const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
 
 log("Initializing map...");
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 const mapArea = mapSize*mapSize;
 
 // create tile classes
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clSettlement = createTileClass();
 var clLand = createTileClass();
 
 // randomize player order
 var playerIDs = [];
 for (var i = 0; i < numPlayers; i++)
 	playerIDs.push(i+1);
 
 playerIDs = sortPlayers(playerIDs);
 
 // place players
 var playerX = new Array(numPlayers);
 var playerZ = new Array(numPlayers);
 var playerAngle = new Array(numPlayers);
 
 var startAngle = PI/2 + PI/14;
 for (var i = 0; i < numPlayers; i++)
 {
 	playerAngle[i] = startAngle - (i+1)*(PI+ PI/7)/(numPlayers+1);
 	playerX[i] = 0.5 + 0.35*cos(playerAngle[i]);
 	playerZ[i] = 0.5 + 0.35*sin(playerAngle[i]);
 }
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	// some constants
 	var radius = scaleByMapSize(15,25);
 	var shoreRadius = 4;
 	var elevation = 3;
 
 	var hillSize = PI * radius * radius;
 	// get the x and z in tiles
 	fx = fractionToTiles(playerX[i]);
 	fz = fractionToTiles(playerZ[i]);
 	ix = round(fx);
 	iz = round(fz);
 	// create the hill
 	var placer = new ClumpPlacer(hillSize, 0.80, 0.1, 10, ix, iz);
 	var terrainPainter = new LayeredPainter(
 		[tWater , tShore, tMainTerrain],		// terrains
 		[1, shoreRadius]		// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		elevation,				// elevation
 		shoreRadius				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clPlayer)], null);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tRoadWild, tRoad], [1]);
 	createArea(placer, painter, null);
 
 	// create starting units
 	placeCivDefaultEntities(fx, fz, id, { 'iberWall': false });
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oFruitBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create woods
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 13;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oWood, 14,14, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 		mAngle = randFloat(0, TWO_PI);
 
 	var mDist = radius - 4;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 	var hillSize = PI * radius * radius;
 	// create starting trees
 	var num = floor(hillSize / 60);
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = 11;
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oTree1, num, num, 0,4)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 
 	//create docks
 	var dockLocation = getTIPIADBON([ix, iz], [mapSize / 2, mapSize / 2], [-3 , 2.6], 0.5, 3);
 	if (dockLocation !== undefined)
 		placeObject(dockLocation[0], dockLocation[1], "structures/" + getCivCode(id-1) + "_dock", id, playerAngle[i] + PI);
 }
 RMS.SetProgress(15);
 
 //Create the continent body
 var fx = fractionToTiles(0.12);
 var fz = fractionToTiles(0.5);
 var ix = round(fx);
 var iz = round(fz);
 
 var placer = new ClumpPlacer(mapArea * 0.50, 0.80, 0.08, 10, ix, iz);
 var terrainPainter = new LayeredPainter(
 	[tWater, tShore, tMainTerrain],		// terrains
 	[4, 2]		// widths
 );
 var elevationPainter = new SmoothElevationPainter(
 	ELEVATION_SET,			// type
 	3,				// elevation
 	4				// blend radius
 );
 createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], avoidClasses(clPlayer, 8));
 RMS.SetProgress(20);
 
 log("Creating shore jaggedness...");
 placer = new ClumpPlacer(scaleByMapSize(15, 80), 0.2, 0.1, 1);
 terrainPainter = new LayeredPainter(
 	[tMainTerrain, tMainTerrain],		// terrains
 	[2]								// widths
 );
 elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 4);
 createAreas(
 	placer,
 	[terrainPainter, elevationPainter, paintClass(clLand)],
 	[borderClasses(clLand, 6, 3), avoidClasses(clPlayer, 8)],
 	scaleByMapSize(20, 150) * 2, 150
 );
 
 paintTerrainBasedOnHeight(1, 3, 0, tShore);
 paintTerrainBasedOnHeight(-8, 1, 2, tWater);
 RMS.SetProgress(25);
 
 log("Creating bumps...");
 placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1);
 painter = new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2);
 createAreas(
 	placer,
 	painter,
 	[avoidClasses(clPlayer, 10), stayClasses(clLand, 3)],
 	scaleByMapSize(100, 200)
 );
 RMS.SetProgress(30);
 
 log("Creating hills...");
 placer = new ClumpPlacer(scaleByMapSize(20, 150), 0.2, 0.1, 1);
 terrainPainter = new LayeredPainter(
 	[tCliff, tHill],		// terrains
 	[2]								// widths
 );
 elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 18, 2);
 createAreas(
 	placer,
 	[terrainPainter, elevationPainter, paintClass(clHill)],
 	[avoidClasses(clPlayer, 10, clHill, 15), stayClasses(clLand, 7)],
 	scaleByMapSize(1, 4) * numPlayers
 );
 RMS.SetProgress(34);
 
 // calculate desired number of trees for map (based on size)
 if (random_terrain == g_BiomeSavanna)
 {
 	var MIN_TREES = 200;
 	var MAX_TREES = 1250;
 	var P_FOREST = 0.02;
 }
 else if (random_terrain == g_BiomeTropic)
 {
 	var MIN_TREES = 1000;
 	var MAX_TREES = 6000;
 	var P_FOREST = 0.6;
 }
 else
 {
 	var MIN_TREES = 500;
 	var MAX_TREES = 3000;
 	var P_FOREST = 0.7;
 }
 
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 var numForest = totalTrees * P_FOREST;
 var numStragglers = totalTrees * (1.0 - P_FOREST);
 
 log("Creating forests...");
 var types = [
 	[[tForestFloor2, tMainTerrain, pForest1], [tForestFloor2, pForest1]],
 	[[tForestFloor1, tMainTerrain, pForest2], [tForestFloor1, pForest2]]
 ];	// some variation
 
 var size = numForest / (scaleByMapSize(2,8) * numPlayers) *
 	(random_terrain == g_BiomeSavanna ? 2 : 1);
 
 var num = floor(size / types.length);
 for (var i = 0; i < types.length; ++i)
 {
 	placer = new ClumpPlacer(numForest / num, 0.1, 0.1, 1);
 	painter = new LayeredPainter(
 		types[i],		// terrains
 		[2]											// widths
 		);
 	createAreas(
 		placer,
 		[painter, paintClass(clForest)],
 		[avoidClasses(clPlayer, 6, clForest, 10, clHill, 0), stayClasses(clLand, 7)],
 		num
 	);
 }
 RMS.SetProgress(38);
 
 log("Creating dirt patches...");
 var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
 for (var i = 0; i < sizes.length; i++)
 {
 	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
 	painter = new LayeredPainter(
 		[[tMainTerrain,tTier1Terrain],[tTier1Terrain,tTier2Terrain], [tTier2Terrain,tTier3Terrain]], 		// terrains
 		[1,1]															// widths
 	);
 	createAreas(
 		placer,
 		[painter, paintClass(clDirt)],
 		[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 0), stayClasses(clLand, 7)],
 		scaleByMapSize(15, 45)
 	);
 }
 RMS.SetProgress(42);
 
 log("Creating grass patches...");
 var sizes = [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)];
 for (var i = 0; i < sizes.length; i++)
 {
 	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
 	painter = new TerrainPainter(tTier4Terrain);
 	createAreas(
 		placer,
 		painter,
 		[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 0), stayClasses(clLand, 7)],
 		scaleByMapSize(15, 45)
 	);
 }
 RMS.SetProgress(46);
 
 log("Creating stone mines...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
 createObjectGroups(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 10, clRock, 10, clHill, 1), stayClasses(clLand, 7)],
 	scaleByMapSize(4,16), 100
 );
 RMS.SetProgress(50);
 
 log("Creating small stone quarries...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroups(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 10, clRock, 10, clHill, 1), stayClasses(clLand, 7)],
 	scaleByMapSize(4,16), 100
 );
 RMS.SetProgress(54);
 
 log("Creating metal mines...");
 // create large metal quarries
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroups(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 10, clMetal, 10, clRock, 5, clHill, 1), stayClasses(clLand, 7)],
 	scaleByMapSize(4,16), 100
 );
 RMS.SetProgress(58);
 
 // create small decorative rocks
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockMedium, 1,3, 0,1)],
 	true
 );
 createObjectGroups(
 	group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 6)],
 	scaleByMapSize(16, 262), 50
 );
 RMS.SetProgress(62);
 
 // create large decorative rocks
 log("Creating large decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
 	true
 );
 createObjectGroups(
 	group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 6)],
 	scaleByMapSize(8, 131), 50
 );
 RMS.SetProgress(66);
 
 log("Creating deer...");
 group = new SimpleGroup(
 	[new SimpleObject(oMainHuntableAnimal, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 10, clHill, 1, clFood, 20), stayClasses(clLand, 7)],
 	3 * numPlayers, 50
 );
 RMS.SetProgress(70);
 
 log("Creating sheep...");
 group = new SimpleGroup(
 	[new SimpleObject(oSecondaryHuntableAnimal, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 10, clHill, 1, clFood, 20), stayClasses(clLand, 7)],
 	3 * numPlayers, 50
 );
 RMS.SetProgress(74);
 
 log("Creating fruit bush...");
 group = new SimpleGroup(
 	[new SimpleObject(oFruitBush, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 8, clHill, 1, clFood, 20), stayClasses(clLand, 7)],
 	randInt(1, 4) * numPlayers + 2, 50
 );
 RMS.SetProgress(78);
 
 log("Creating fish...");
 createObjectGroups(
 	new SimpleGroup([new SimpleObject(oFish, 2,3, 0,2)], true, clFood),
 	0,
 	avoidClasses(clLand, 2, clPlayer, 2, clHill, 0, clFood, 20),
 	25 * numPlayers, 60
 );
 RMS.SetProgress(82);
 
 log("Creating straggler trees...");
 var types = [oTree1, oTree2, oTree4, oTree3];	// some variation
 var num = floor(numStragglers / types.length);
 for (var i = 0; i < types.length; ++i)
 {
 	group = new SimpleGroup(
 		[new SimpleObject(types[i], 1,1, 0,3)],
 		true, clForest
 	);
 	createObjectGroups(group, 0,
 		[avoidClasses(clForest, 1, clHill, 1, clPlayer, 9, clMetal, 6, clRock, 6), stayClasses(clLand, 9)],
 		num
 	);
 }
 RMS.SetProgress(86);
 
 var planetm = random_terrain == g_BiomeTropic ? 8 : 1;
 
 log("Creating small grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)]
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clHill, 2, clPlayer, 2, clDirt, 0), stayClasses(clLand, 6)],
 	planetm * scaleByMapSize(13, 200)
 );
 RMS.SetProgress(90);
 
 log("Creating large grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aGrass, 2,4, 0,1.8, -PI/8,PI/8), new SimpleObject(aGrassShort, 3,6, 1.2,2.5, -PI/8,PI/8)]
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clHill, 2, clPlayer, 2, clDirt, 1, clForest, 0), stayClasses(clLand, 6)],
 	planetm * scaleByMapSize(13, 200)
 );
 RMS.SetProgress(94);
 
 log("Creating bushes...");
 group = new SimpleGroup(
 	[new SimpleObject(aBushMedium, 1,2, 0,2), new SimpleObject(aBushSmall, 2,4, 0,2)]
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clHill, 1, clPlayer, 1, clDirt, 1), stayClasses(clLand, 6)],
 	planetm * scaleByMapSize(13, 200), 50
 );
 RMS.SetProgress(98);
 
-random_terrain = randInt(1,3);
-if (random_terrain == 1)
-	setSkySet("cirrus");
-else if (random_terrain == 2)
-	setSkySet("cumulus");
-else if (random_terrain == 3)
-	setSkySet("sunny");
-
+setSkySet(pickRandom(["cirrus", "cumulus", "sunny"]));
 setSunRotation(randFloat(0, TWO_PI));
 setSunElevation(randFloat(PI/ 5, PI / 3));
 setWaterWaviness(2);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/rmgen/randombiome.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/rmgen/randombiome.js	(revision 19285)
+++ ps/trunk/binaries/data/mods/public/maps/random/rmgen/randombiome.js	(revision 19286)
@@ -1,879 +1,873 @@
 const g_BiomeTemperate = 1;
 const g_BiomeSnowy = 2;
 const g_BiomeDesert = 3;
 const g_BiomeAlpine = 4;
 const g_BiomeMediterranean = 5;
 const g_BiomeSavanna = 6;
 const g_BiomeTropic = 7;
 const g_BiomeAutumn = 8;
 
 var g_BiomeID = g_BiomeTemperate;
 
 var g_Terrains = {
 	"mainTerrain": ["temp_grass_long_b"],
 	"forestFloor1": "temp_forestfloor_pine",
 	"forestFloor2": "temp_plants_bog",
 	"tier1Terrain": "temp_grass_d",
 	"tier2Terrain": "temp_grass_c",
 	"tier3Terrain": "temp_grass_clovers_2",
 	"tier4Terrain": "temp_grass_plants",
 	"cliff": ["temp_cliff_a", "temp_cliff_b"],
 	"hill": ["temp_dirt_gravel", "temp_dirt_gravel_b"],
 	"dirt": ["temp_dirt_gravel", "temp_dirt_gravel_b"],
 	"road": "temp_road",
 	"roadWild": "temp_road_overgrown",
 	"shoreBlend": "temp_mud_plants",
 	"shore": "sand_grass_25",
 	"water": "medit_sand_wet"
 };
 
 var g_Gaia = {
 	"tree1": "gaia/flora_tree_oak",
 	"tree2": "gaia/flora_tree_oak_large",
 	"tree3": "gaia/flora_tree_apple",
 	"tree4": "gaia/flora_tree_pine",
 	"tree5": "gaia/flora_tree_aleppo_pine",
 	"fruitBush": "gaia/flora_bush_berry",
 	"chicken": "gaia/fauna_chicken",
 	"fish": "gaia/fauna_fish",
 	"mainHuntableAnimal": "gaia/fauna_deer",
 	"secondaryHuntableAnimal": "gaia/fauna_sheep",
 	"stoneLarge": "gaia/geology_stonemine_medit_quarry",
 	"stoneSmall": "gaia/geology_stone_mediterranean",
 	"metalLarge": "gaia/geology_metal_mediterranean_slabs"
 };
 
 var g_Decoratives = {
 	"grass": "actor|props/flora/grass_soft_large_tall.xml",
 	"grassShort": "actor|props/flora/grass_soft_large.xml",
 	"reeds": "actor|props/flora/reeds_pond_lush_a.xml",
 	"lillies": "actor|props/flora/pond_lillies_large.xml",
 	"rockLarge": "actor|geology/stone_granite_large.xml",
 	"rockMedium": "actor|geology/stone_granite_med.xml",
 	"bushMedium": "actor|props/flora/bush_medit_me.xml",
 	"bushSmall": "actor|props/flora/bush_medit_sm.xml",
 	"tree": "actor|flora/trees/oak.xml"
 };
 
 /**
  * Randomizes environment, optionally excluding some biome IDs.
  */
 function randomizeBiome(avoid = [])
 {
 	let biomeIndex;
 	do
 		biomeIndex = randInt(1, 8);
 	while (avoid.indexOf(biomeIndex) != -1);
 
 	setBiome(biomeIndex);
 
 	return biomeIndex;
 }
 
 function setBiome(biomeIndex)
 {
-	var random_sky = randInt(1,3);
-	if (random_sky==1)
-		setSkySet("cirrus");
-	else if (random_sky ==2)
-		setSkySet("cumulus");
-	else if (random_sky ==3)
-		setSkySet("sunny");
+	setSkySet(pickRandom(["cirrus", "cumulus", "sunny"]));
 
 	setSunRotation(randFloat(0, TWO_PI));
 	setSunElevation(randFloat(PI/ 6, PI / 3));
 
 	setUnitsAmbientColor(0.57, 0.58, 0.55);
 	setTerrainAmbientColor(0.447059, 0.509804, 0.54902);
 
 	g_BiomeID = biomeIndex;
 
 	if (g_BiomeID == g_BiomeTemperate)
 	{
 		// temperate ocean blue, a bit too deep and saturated perhaps but it looks nicer.
 		// this assumes ocean settings, maps that aren't oceans should reset.
 		setWaterColor(0.114, 0.192, 0.463);
 		setWaterTint(0.255, 0.361, 0.651);
 		setWaterWaviness(5.5);
 		setWaterMurkiness(0.83);
 
 		setFogThickness(0.25);
 		setFogFactor(0.4);
 
 		setPPEffect("hdr");
 		setPPSaturation(0.62);
 		setPPContrast(0.62);
 		setPPBloom(0.3);
 
 		g_Terrains = {
 			"cliff": ["temp_cliff_a", "temp_cliff_b"],
 			"hill": ["temp_dirt_gravel", "temp_dirt_gravel_b"],
 			"dirt": ["temp_dirt_gravel", "temp_dirt_gravel_b"],
 			"road": "temp_road",
 			"roadWild": "temp_road_overgrown",
 			"shoreBlend": "temp_mud_plants",
 			"shore": "sand_grass_25",
 			"water": "medit_sand_wet"
 		};
 
 		if (randInt(2))
 		{
 			g_Terrains.mainTerrain = "alpine_grass";
 			g_Terrains.forestFloor1 = "temp_forestfloor_pine";
 			g_Terrains.forestFloor2 = "temp_grass_clovers_2";
 			g_Terrains.tier1Terrain = "alpine_grass_a";
 			g_Terrains.tier2Terrain = "alpine_grass_b";
 			g_Terrains.tier3Terrain = "alpine_grass_c";
 			g_Terrains.tier4Terrain = "temp_grass_mossy";
 		}
 		else
 		{
 			g_Terrains.mainTerrain = "temp_grass_long_b";
 			g_Terrains.forestFloor1 = "temp_forestfloor_pine";
 			g_Terrains.forestFloor2 = "temp_plants_bog";
 			g_Terrains.tier1Terrain = "temp_grass_d";
 			g_Terrains.tier2Terrain = "temp_grass_c";
 			g_Terrains.tier3Terrain = "temp_grass_clovers_2";
 			g_Terrains.tier4Terrain = "temp_grass_plants";
 		}
 
 		g_Gaia = {
 			"fruitBush": "gaia/flora_bush_berry",
 			"chicken": "gaia/fauna_chicken",
 			"fish": "gaia/fauna_fish",
 			"mainHuntableAnimal": "gaia/fauna_deer",
 			"secondaryHuntableAnimal": "gaia/fauna_sheep",
 			"stoneLarge": "gaia/geology_stonemine_temperate_quarry",
 			"stoneSmall": "gaia/geology_stone_temperate",
 			"metalLarge": "gaia/geology_metal_temperate_slabs"
 		};
 
 		var random_trees = randInt(3);
 		if (random_trees == 0)
 		{
 			g_Gaia.tree1 = "gaia/flora_tree_oak";
 			g_Gaia.tree2 = "gaia/flora_tree_oak_large";
 		}
 		else if (random_trees == 1)
 		{
 			g_Gaia.tree1 = "gaia/flora_tree_poplar";
 			g_Gaia.tree2 = "gaia/flora_tree_poplar";
 		}
 		else
 		{
 			g_Gaia.tree1 = "gaia/flora_tree_euro_beech";
 			g_Gaia.tree2 = "gaia/flora_tree_euro_beech";
 		}
 		g_Gaia.tree3 = "gaia/flora_tree_apple";
 		random_trees = randInt(3);
 		if (random_trees == 0)
 		{
 			g_Gaia.tree4 = "gaia/flora_tree_pine";
 			g_Gaia.tree5 = "gaia/flora_tree_aleppo_pine";
 		}
 		else if (random_trees == 1)
 		{
 			g_Gaia.tree4 = "gaia/flora_tree_pine";
 			g_Gaia.tree5 = "gaia/flora_tree_pine";
 		}
 		else
 		{
 			g_Gaia.tree4 = "gaia/flora_tree_aleppo_pine";
 			g_Gaia.tree5 = "gaia/flora_tree_aleppo_pine";
 		}
 
 		g_Decoratives = {
 			"grass": "actor|props/flora/grass_soft_large_tall.xml",
 			"grassShort": "actor|props/flora/grass_soft_large.xml",
 			"reeds": "actor|props/flora/reeds_pond_lush_a.xml",
 			"lillies": "actor|props/flora/water_lillies.xml",
 			"rockLarge": "actor|geology/stone_granite_large.xml",
 			"rockMedium": "actor|geology/stone_granite_med.xml",
 			"bushMedium": "actor|props/flora/bush_medit_me.xml",
 			"bushSmall": "actor|props/flora/bush_medit_sm.xml",
 			"tree": "actor|flora/trees/oak.xml"
 		};
 	}
 	else if (g_BiomeID == g_BiomeSnowy)
 	{
 		setSunColor(0.550, 0.601, 0.644);				// a little darker
 		// Water is a semi-deep blue, fairly wavy, fairly murky for an ocean.
 		// this assumes ocean settings, maps that aren't oceans should reset.
 		setWaterColor(0.067, 0.212, 0.361);
 		setWaterTint(0.4, 0.486, 0.765);
 		setWaterWaviness(5.5);
 		setWaterMurkiness(0.83);
 
 		g_Terrains = {
 			"mainTerrain": ["polar_snow_b", "snow grass 75", "snow rocks", "snow forest"],
 			"forestFloor1": "polar_tundra_snow",
 			"forestFloor2": "polar_tundra_snow",
 			"cliff": ["alpine_cliff_a", "alpine_cliff_b"],
 			"tier1Terrain": "polar_snow_a",
 			"tier2Terrain": "polar_ice_snow",
 			"tier3Terrain": "polar_ice",
 			"tier4Terrain": "snow grass 2",
 			"hill": ["polar_snow_rocks", "polar_cliff_snow"],
 			"dirt": "snow grass 2",
 			"road": "new_alpine_citytile",
 			"roadWild": "polar_ice_cracked",
 			"shoreBlend": "polar_ice",
 			"shore": "alpine_shore_rocks_icy",
 			"water": "alpine_shore_rocks"
 		};
 
 		g_Gaia = {
 			"tree1": "gaia/flora_tree_pine_w",
 			"tree2": "gaia/flora_tree_pine_w",
 			"tree3": "gaia/flora_tree_pine_w",
 			"tree4": "gaia/flora_tree_pine_w",
 			"tree5": "gaia/flora_tree_pine",
 			"fruitBush": "gaia/flora_bush_berry",
 			"chicken": "gaia/fauna_chicken",
 			"mainHuntableAnimal": "gaia/fauna_muskox",
 			"fish": "gaia/fauna_fish_tuna",
 			"secondaryHuntableAnimal": "gaia/fauna_walrus",
 			"stoneLarge": "gaia/geology_stonemine_alpine_quarry",
 			"stoneSmall": "gaia/geology_stone_alpine_a",
 			"metalLarge": "gaia/geology_metal_alpine_slabs"
 		};
 
 		g_Decoratives = {
 			"grass": "actor|props/flora/grass_soft_dry_small_tall.xml",
 			"grassShort": "actor|props/flora/grass_soft_dry_large.xml",
 			"reeds": "actor|props/flora/reeds_pond_dry.xml",
 			"lillies": "actor|geology/stone_granite_large.xml",
 			"rockLarge": "actor|geology/stone_granite_large.xml",
 			"rockMedium": "actor|geology/stone_granite_med.xml",
 			"bushMedium": "actor|props/flora/bush_desert_dry_a.xml",
 			"bushSmall": "actor|props/flora/bush_desert_dry_a.xml",
 			"tree": "actor|flora/trees/pine_w.xml"
 		};
 
 		setFogFactor(0.6);
 		setFogThickness(0.21);
 		setPPSaturation(0.37);
 		setPPEffect("hdr");
 	}
 	else if (g_BiomeID == g_BiomeDesert)
 	{
 		setSunColor(0.733, 0.746, 0.574);
 
 		// Went for a very clear, slightly blue-ish water in this case, basically no waves.
 		setWaterColor(0, 0.227, 0.843);
 		setWaterTint(0, 0.545, 0.859);
 		setWaterWaviness(1);
 		setWaterMurkiness(0.22);
 
 		setFogFactor(0.5);
 		setFogThickness(0.0);
 		setFogColor(0.852, 0.746, 0.493);
 
 		setPPEffect("hdr");
 		setPPContrast(0.67);
 		setPPSaturation(0.42);
 		setPPBloom(0.23);
 
 		g_Terrains = {
 			"mainTerrain": ["desert_dirt_rough", "desert_dirt_rough_2", "desert_sand_dunes_50", "desert_sand_smooth"],
 			"forestFloor1": "forestfloor_dirty",
 			"forestFloor2": "desert_forestfloor_palms",
 			"cliff": ["desert_cliff_1", "desert_cliff_2", "desert_cliff_3", "desert_cliff_4", "desert_cliff_5"],
 			"tier1Terrain": "desert_dirt_rough",
 			"tier2Terrain": "desert_dirt_rocks_1",
 			"tier3Terrain": "desert_dirt_rocks_2",
 			"tier4Terrain": "desert_dirt_rough",
 			"hill": ["desert_dirt_rocks_1", "desert_dirt_rocks_2", "desert_dirt_rocks_3"],
 			"dirt": ["desert_lakebed_dry", "desert_lakebed_dry_b"],
 			"road": "desert_city_tile",
 			"roadWild": "desert_city_tile",
 			"shoreBlend": "desert_shore_stones",
 			"shore": "desert_sand_smooth",
 			"water": "desert_sand_wet"
 		};
 
 		g_Gaia = {
 			"fruitBush": "gaia/flora_bush_grapes",
 			"chicken": "gaia/fauna_chicken",
 			"mainHuntableAnimal": "gaia/fauna_camel",
 			"fish": "gaia/fauna_fish",
 			"secondaryHuntableAnimal": "gaia/fauna_gazelle",
 			"stoneLarge": "gaia/geology_stonemine_desert_quarry",
 			"stoneSmall": "gaia/geology_stone_desert_small",
 			"metalLarge": "gaia/geology_metal_desert_slabs"
 		};
 		if (randInt(2))
 		{
 			g_Gaia.tree1 = "gaia/flora_tree_cretan_date_palm_short";
 			g_Gaia.tree2 = "gaia/flora_tree_cretan_date_palm_tall";
 		}
 		else
 		{
 			g_Gaia.tree1 = "gaia/flora_tree_date_palm";
 			g_Gaia.tree2 = "gaia/flora_tree_date_palm";
 		}
 		g_Gaia.tree3 = "gaia/flora_tree_fig";
 		if (randInt(2))
 		{
 			g_Gaia.tree4 = "gaia/flora_tree_tamarix";
 			g_Gaia.tree5 = "gaia/flora_tree_tamarix";
 		}
 		else
 		{
 			g_Gaia.tree4 = "gaia/flora_tree_senegal_date_palm";
 			g_Gaia.tree5 = "gaia/flora_tree_senegal_date_palm";
 		}
 
 		g_Decoratives = {
 			"grass": "actor|props/flora/grass_soft_dry_small_tall.xml",
 			"grassShort": "actor|props/flora/grass_soft_dry_large.xml",
 			"reeds": "actor|props/flora/reeds_pond_lush_a.xml",
 			"lillies": "actor|props/flora/reeds_pond_lush_b.xml",
 			"rockLarge": "actor|geology/stone_desert_med.xml",
 			"rockMedium": "actor|geology/stone_desert_med.xml",
 			"bushMedium": "actor|props/flora/bush_desert_dry_a.xml",
 			"bushSmall": "actor|props/flora/bush_desert_dry_a.xml",
 			"tree": "actor|flora/trees/palm_date.xml"
 		};
 	}
 	else if (g_BiomeID == g_BiomeAlpine)
 	{
 		// simulates an alpine lake, fairly deep.
 		// this is not intended for a clear running river, or even an ocean.
 		setWaterColor(0.0, 0.047, 0.286);				// dark majestic blue
 		setWaterTint(0.471, 0.776, 0.863);				// light blue
 		setWaterMurkiness(0.82);
 		setWaterWaviness(2);
 
 		setFogThickness(0.26);
 		setFogFactor(0.4);
 
 		setPPEffect("hdr");
 		setPPSaturation(0.48);
 		setPPContrast(0.53);
 		setPPBloom(0.12);
 
 		g_Terrains = {
 			"mainTerrain": ["alpine_dirt_grass_50"],
 			"forestFloor1": "alpine_forrestfloor",
 			"forestFloor2": "alpine_forrestfloor",
 			"cliff": ["alpine_cliff_a", "alpine_cliff_b", "alpine_cliff_c"],
 			"tier1Terrain": "alpine_dirt",
 			"tier2Terrain": ["alpine_grass_snow_50", "alpine_dirt_snow", "alpine_dirt_snow"],
 			"tier3Terrain": ["alpine_snow_a", "alpine_snow_b"],
 			"tier4Terrain": "new_alpine_grass_a",
 			"hill": "alpine_cliff_snow",
 			"dirt": ["alpine_dirt", "alpine_grass_d"],
 			"road": "new_alpine_citytile",
 			"roadWild": "new_alpine_citytile",
 			"shoreBlend": "alpine_shore_rocks",
 			"shore": "alpine_shore_rocks_grass_50",
 			"water": "alpine_shore_rocks"
 		};
 
 		g_Gaia = {
 			"tree1": "gaia/flora_tree_pine",
 			"tree2": "gaia/flora_tree_pine",
 			"tree3": "gaia/flora_tree_pine",
 			"tree4": "gaia/flora_tree_pine",
 			"tree5": "gaia/flora_tree_pine",
 			"fruitBush": "gaia/flora_bush_berry",
 			"chicken": "gaia/fauna_chicken",
 			"mainHuntableAnimal": "gaia/fauna_goat",
 			"fish": "gaia/fauna_fish_tuna",
 			"secondaryHuntableAnimal": "gaia/fauna_deer",
 			"stoneLarge": "gaia/geology_stonemine_alpine_quarry",
 			"stoneSmall": "gaia/geology_stone_alpine_a",
 			"metalLarge": "gaia/geology_metal_alpine_slabs"
 		};
 
 		g_Decoratives = {
 			"grass": "actor|props/flora/grass_soft_small_tall.xml",
 			"grassShort": "actor|props/flora/grass_soft_large.xml",
 			"reeds": "actor|props/flora/reeds_pond_dry.xml",
 			"lillies": "actor|geology/stone_granite_large.xml",
 			"rockLarge": "actor|geology/stone_granite_large.xml",
 			"rockMedium": "actor|geology/stone_granite_med.xml",
 			"bushMedium": "actor|props/flora/bush_desert_a.xml",
 			"bushSmall": "actor|props/flora/bush_desert_a.xml",
 			"tree": "actor|flora/trees/pine.xml"
 		};
 	}
 	else if (g_BiomeID == g_BiomeMediterranean)
 	{
 		// Guess what, this is based on the colors of the mediterranean sea.
 		setWaterColor(0.024,0.212,0.024);
 		setWaterTint(0.133, 0.725,0.855);
 		setWaterWaviness(3);
 		setWaterMurkiness(0.8);
 
 		setFogFactor(0.3);
 		setFogThickness(0.25);
 
 		setPPEffect("hdr");
 		setPPContrast(0.62);
 		setPPSaturation(0.51);
 		setPPBloom(0.12);
 
 		g_Terrains = {
 			"mainTerrain": ["medit_grass_field_a", "medit_grass_field_b"],
 			"forestFloor1": "medit_grass_field",
 			"forestFloor2": "medit_grass_shrubs",
 			"cliff": ["medit_cliff_grass", "medit_cliff_greek", "medit_cliff_greek_2", "medit_cliff_aegean", "medit_cliff_italia", "medit_cliff_italia_grass"],
 			"tier1Terrain": "medit_grass_field_b",
 			"tier2Terrain": "medit_grass_field_brown",
 			"tier3Terrain": "medit_grass_field_dry",
 			"tier4Terrain": "medit_grass_wild",
 			"hill": ["medit_rocks_grass_shrubs", "medit_rocks_shrubs"],
 			"dirt": ["medit_dirt", "medit_dirt_b"],
 			"road": "medit_city_tile",
 			"roadWild": "medit_city_tile",
 			"shoreBlend": "medit_sand",
 			"shore": "sand_grass_25",
 			"water": "medit_sand_wet"
 		};
 
 		g_Gaia = {
 			"chicken": "gaia/fauna_chicken",
 			"mainHuntableAnimal": "gaia/fauna_deer",
 			"fish": "gaia/fauna_fish",
 			"secondaryHuntableAnimal": "gaia/fauna_sheep",
 			"stoneLarge": "gaia/geology_stonemine_medit_quarry",
 			"stoneSmall": "gaia/geology_stone_mediterranean",
 			"metalLarge": "gaia/geology_metal_mediterranean_slabs"
 		};
 
 		var random_trees = randInt(3);
 		if (random_trees == 0)
 		{
 			g_Gaia.tree1 = "gaia/flora_tree_cretan_date_palm_short";
 			g_Gaia.tree2 = "gaia/flora_tree_cretan_date_palm_tall";
 		}
 		else if (random_trees == 1)
 		{
 			g_Gaia.tree1 = "gaia/flora_tree_carob";
 			g_Gaia.tree2 = "gaia/flora_tree_carob";
 		}
 		else
 		{
 			g_Gaia.tree1 = "gaia/flora_tree_medit_fan_palm";
 			g_Gaia.tree2 = "gaia/flora_tree_medit_fan_palm";
 		}
 
 		if (randInt(2))
 			g_Gaia.tree3 = "gaia/flora_tree_apple";
 		else
 			g_Gaia.tree3 = "gaia/flora_tree_poplar_lombardy";
 
 		if (randInt(2))
 		{
 			g_Gaia.tree4 = "gaia/flora_tree_cypress";
 			g_Gaia.tree5 = "gaia/flora_tree_cypress";
 		}
 		else
 		{
 			g_Gaia.tree4 = "gaia/flora_tree_aleppo_pine";
 			g_Gaia.tree5 = "gaia/flora_tree_aleppo_pine";
 		}
 
 		if (randInt(2))
 			g_Gaia.fruitBush = "gaia/flora_bush_berry";
 		else
 			g_Gaia.fruitBush = "gaia/flora_bush_grapes";
 
 		g_Decoratives = {
 			"grass": "actor|props/flora/grass_soft_large_tall.xml",
 			"grassShort": "actor|props/flora/grass_soft_large.xml",
 			"reeds": "actor|props/flora/reeds_pond_lush_b.xml",
 			"lillies": "actor|props/flora/water_lillies.xml",
 			"rockLarge": "actor|geology/stone_granite_large.xml",
 			"rockMedium": "actor|geology/stone_granite_med.xml",
 			"bushMedium": "actor|props/flora/bush_medit_me.xml",
 			"bushSmall": "actor|props/flora/bush_medit_sm.xml",
 			"tree": "actor|flora/trees/palm_cretan_date.xml"
 		};
 	}
 	else if (g_BiomeID == g_BiomeSavanna)
 	{
 		// Using the Malawi as a reference, in parts where it's not too murky from a river nearby.
 		setWaterColor(0.055,0.176,0.431);
 		setWaterTint(0.227,0.749,0.549);
 		setWaterWaviness(1.5);
 		setWaterMurkiness(0.77);
 
 		setFogFactor(0.25);
 		setFogThickness(0.15);
 		setFogColor(0.847059, 0.737255, 0.482353);
 
 		setPPEffect("hdr");
 		setPPContrast(0.57031);
 		setPPBloom(0.34);
 
 		g_Terrains = {
 			"mainTerrain": ["savanna_grass_a", "savanna_grass_b"],
 			"forestFloor1": "savanna_forestfloor_a",
 			"forestFloor2": "savanna_forestfloor_b",
 			"cliff": ["savanna_cliff_a", "savanna_cliff_b"],
 			"tier1Terrain": "savanna_shrubs_a",
 			"tier2Terrain": "savanna_dirt_rocks_b",
 			"tier3Terrain": "savanna_dirt_rocks_a",
 			"tier4Terrain": "savanna_grass_a",
 			"hill": ["savanna_grass_a", "savanna_grass_b"],
 			"dirt": ["savanna_dirt_rocks_b", "dirt_brown_e"],
 			"road": "savanna_tile_a",
 			"roadWild": "savanna_tile_a",
 			"shoreBlend": "savanna_riparian",
 			"shore": "savanna_riparian_bank",
 			"water": "savanna_riparian_wet"
 		};
 
 		g_Gaia = {
 			"tree1": "gaia/flora_tree_baobab",
 			"tree2": "gaia/flora_tree_baobab",
 			"tree3": "gaia/flora_tree_baobab",
 			"tree4": "gaia/flora_tree_baobab",
 			"tree5": "gaia/flora_tree_baobab",
 			"fruitBush": "gaia/flora_bush_grapes",
 			"chicken": "gaia/fauna_chicken",
 			"fish": "gaia/fauna_fish",
 			"secondaryHuntableAnimal": "gaia/fauna_gazelle",
 			"stoneLarge": "gaia/geology_stonemine_desert_quarry",
 			"stoneSmall": "gaia/geology_stone_savanna_small",
 			"metalLarge": "gaia/geology_metal_savanna_slabs"
 		};
 
 		var rts = randInt(1,4);
 		if (rts == 1)
 			g_Gaia.mainHuntableAnimal = "gaia/fauna_wildebeest";
 		else if (rts == 2)
 			g_Gaia.mainHuntableAnimal = "gaia/fauna_zebra";
 		else if (rts == 3)
 			g_Gaia.mainHuntableAnimal = "gaia/fauna_giraffe";
 		else if (rts == 4)
 			g_Gaia.mainHuntableAnimal = "gaia/fauna_elephant_african_bush";
 
 		g_Decoratives = {
 			"grass": "actor|props/flora/grass_savanna.xml",
 			"grassShort": "actor|props/flora/grass_medit_field.xml",
 			"reeds": "actor|props/flora/reeds_pond_lush_a.xml",
 			"lillies": "actor|props/flora/reeds_pond_lush_b.xml",
 			"rockLarge": "actor|geology/stone_savanna_med.xml",
 			"rockMedium": "actor|geology/stone_savanna_med.xml",
 			"bushMedium": "actor|props/flora/bush_desert_dry_a.xml",
 			"bushSmall": "actor|props/flora/bush_dry_a.xml",
 			"tree": "actor|flora/trees/baobab.xml"
 		};
 	}
 	else if (g_BiomeID == g_BiomeTropic)
 	{
 
 		// Bora-Bora ish. Quite transparent, not wavy.
 		// Mostly for shallow maps. Maps where the water level goes deeper should use a much darker Water Color to simulate deep water holes.
 		setWaterColor(0.584,0.824,0.929);
 		setWaterTint(0.569,0.965,0.945);
 		setWaterWaviness(1.5);
 		setWaterMurkiness(0.35);
 
 		setFogFactor(0.4);
 		setFogThickness(0.2);
 
 		setPPEffect("hdr");
 		setPPContrast(0.67);
 		setPPSaturation(0.62);
 		setPPBloom(0.6);
 
 		g_Terrains = {
 			"mainTerrain": ["tropic_grass_c", "tropic_grass_c", "tropic_grass_c", "tropic_grass_c", "tropic_grass_plants", "tropic_plants", "tropic_plants_b"],
 			"forestFloor1": "tropic_plants_c",
 			"forestFloor2": "tropic_plants_c",
 			"cliff": ["tropic_cliff_a", "tropic_cliff_a", "tropic_cliff_a", "tropic_cliff_a_plants"],
 			"tier1Terrain": "tropic_grass_c",
 			"tier2Terrain": "tropic_grass_plants",
 			"tier3Terrain": "tropic_plants",
 			"tier4Terrain": "tropic_plants_b",
 			"hill": ["tropic_cliff_grass"],
 			"dirt": ["tropic_dirt_a", "tropic_dirt_a_plants"],
 			"road": "tropic_citytile_a",
 			"roadWild": "tropic_citytile_plants",
 			"shoreBlend": "temp_mud_plants",
 			"shore": "tropic_beach_dry_plants",
 			"water": "tropic_beach_dry"
 		};
 
 		g_Gaia = {
 			"tree1": "gaia/flora_tree_toona",
 			"tree2": "gaia/flora_tree_toona",
 			"tree3": "gaia/flora_tree_palm_tropic",
 			"tree4": "gaia/flora_tree_palm_tropic",
 			"tree5": "gaia/flora_tree_palm_tropic",
 			"fruitBush": "gaia/flora_bush_berry",
 			"chicken": "gaia/fauna_chicken",
 			"mainHuntableAnimal": "gaia/fauna_peacock",
 			"fish": "gaia/fauna_fish",
 			"secondaryHuntableAnimal": "gaia/fauna_tiger",
 			"stoneLarge": "gaia/geology_stonemine_tropic_quarry",
 			"stoneSmall": "gaia/geology_stone_tropic_a",
 			"metalLarge": "gaia/geology_metal_tropic_slabs"
 		};
 
 		g_Decoratives = {
 			"grass": "actor|props/flora/plant_tropic_a.xml",
 			"grassShort": "actor|props/flora/plant_lg.xml",
 			"reeds": "actor|props/flora/reeds_pond_lush_b.xml",
 			"lillies": "actor|props/flora/water_lillies.xml",
 			"rockLarge": "actor|geology/stone_granite_large.xml",
 			"rockMedium": "actor|geology/stone_granite_med.xml",
 			"bushMedium": "actor|props/flora/plant_tropic_large.xml",
 			"bushSmall": "actor|props/flora/plant_tropic_large.xml",
 			"tree": "actor|flora/trees/tree_tropic.xml"
 		};
 	}
 	else if (g_BiomeID == g_BiomeAutumn)
 	{
 		// basically temperate with a reddish twist in the reflection and the tint. Also less wavy.
 		// this assumes ocean settings, maps that aren't oceans should reset.
 		setWaterColor(0.157, 0.149, 0.443);
 		setWaterTint(0.443,0.42,0.824);
 		setWaterWaviness(2.5);
 		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");
 
 		g_Terrains = {
 			"mainTerrain": ["temp_grass_aut", "temp_grass_aut", "temp_grass_d_aut"],
 			"forestFloor1": "temp_plants_bog_aut",
 			"forestFloor2": "temp_forestfloor_aut",
 			"cliff": ["temp_cliff_a", "temp_cliff_b"],
 			"tier1Terrain": "temp_grass_plants_aut",
 			"tier2Terrain": ["temp_grass_b_aut", "temp_grass_c_aut"],
 			"tier3Terrain": ["temp_grass_b_aut", "temp_grass_long_b_aut"],
 			"tier4Terrain": "temp_grass_plants_aut",
 			"hill": "temp_highlands_aut",
 			"dirt": ["temp_cliff_a", "temp_cliff_b"],
 			"road": "temp_road_aut",
 			"roadWild": "temp_road_overgrown_aut",
 			"shoreBlend": "temp_grass_plants_aut",
 			"shore": "temp_forestfloor_pine",
 			"water": "medit_sand_wet"
 		};
 
 		g_Gaia = {
 			"tree1": "gaia/flora_tree_euro_beech_aut",
 			"tree2": "gaia/flora_tree_euro_beech_aut",
 			"tree3": "gaia/flora_tree_pine",
 			"tree4": "gaia/flora_tree_oak_aut",
 			"tree5": "gaia/flora_tree_oak_aut",
 			"fruitBush": "gaia/flora_bush_berry",
 			"chicken": "gaia/fauna_chicken",
 			"mainHuntableAnimal": "gaia/fauna_deer",
 			"fish": "gaia/fauna_fish",
 			"secondaryHuntableAnimal": "gaia/fauna_rabbit",
 			"stoneLarge": "gaia/geology_stonemine_temperate_quarry",
 			"stoneSmall": "gaia/geology_stone_temperate",
 			"metalLarge": "gaia/geology_metal_temperate_slabs"
 		};
 
 		g_Decoratives = {
 			"grass": "actor|props/flora/grass_soft_dry_small_tall.xml",
 			"grassShort": "actor|props/flora/grass_soft_dry_large.xml",
 			"reeds": "actor|props/flora/reeds_pond_dry.xml",
 			"lillies": "actor|geology/stone_granite_large.xml",
 			"rockLarge": "actor|geology/stone_granite_large.xml",
 			"rockMedium": "actor|geology/stone_granite_med.xml",
 			"bushMedium": "actor|props/flora/bush_desert_dry_a.xml",
 			"bushSmall": "actor|props/flora/bush_desert_dry_a.xml",
 			"tree": "actor|flora/trees/european_beech_aut.xml"
 		};
 	}
 }
 
 function rBiomeT1()
 {
 	return g_Terrains.mainTerrain;
 }
 
 function rBiomeT2()
 {
 	return g_Terrains.forestFloor1;
 }
 
 function rBiomeT3()
 {
 	return g_Terrains.forestFloor2;
 }
 
 function rBiomeT4()
 {
 	return g_Terrains.cliff;
 }
 
 function rBiomeT5()
 {
 	return g_Terrains.tier1Terrain;
 }
 
 function rBiomeT6()
 {
 	return g_Terrains.tier2Terrain;
 }
 
 function rBiomeT7()
 {
 	return g_Terrains.tier3Terrain;
 }
 
 function rBiomeT8()
 {
 	return g_Terrains.hill;
 }
 
 function rBiomeT9()
 {
 	return g_Terrains.dirt;
 }
 
 function rBiomeT10()
 {
 	return g_Terrains.road;
 }
 
 function rBiomeT11()
 {
 	return g_Terrains.roadWild;
 }
 
 function rBiomeT12()
 {
 	return g_Terrains.tier4Terrain;
 }
 
 function rBiomeT13()
 {
 	return g_Terrains.shoreBlend;
 }
 
 function rBiomeT14()
 {
 	return g_Terrains.shore;
 }
 
 function rBiomeT15()
 {
 	return g_Terrains.water;
 }
 
 function rBiomeE1()
 {
 	return g_Gaia.tree1;
 }
 
 function rBiomeE2()
 {
 	return g_Gaia.tree2;
 }
 
 function rBiomeE3()
 {
 	return g_Gaia.tree3;
 }
 
 function rBiomeE4()
 {
 	return g_Gaia.tree4;
 }
 
 function rBiomeE5()
 {
 	return g_Gaia.tree5;
 }
 
 function rBiomeE6()
 {
 	return g_Gaia.fruitBush;
 }
 
 function rBiomeE7()
 {
 	return g_Gaia.chicken;
 }
 
 function rBiomeE8()
 {
 	return g_Gaia.mainHuntableAnimal;
 }
 
 function rBiomeE9()
 {
 	return g_Gaia.fish;
 }
 
 function rBiomeE10()
 {
 	return g_Gaia.secondaryHuntableAnimal;
 }
 
 function rBiomeE11()
 {
 	return g_Gaia.stoneLarge;
 }
 
 function rBiomeE12()
 {
 	return g_Gaia.stoneSmall;
 }
 
 function rBiomeE13()
 {
 	return g_Gaia.metalLarge;
 }
 
 function rBiomeA1()
 {
 	return g_Decoratives.grass;
 }
 
 function rBiomeA2()
 {
 	return g_Decoratives.grassShort;
 }
 
 function rBiomeA3()
 {
 	return g_Decoratives.reeds;
 }
 
 function rBiomeA4()
 {
 	return g_Decoratives.lillies;
 }
 
 function rBiomeA5()
 {
 	return g_Decoratives.rockLarge;
 }
 
 function rBiomeA6()
 {
 	return g_Decoratives.rockMedium;
 }
 
 function rBiomeA7()
 {
 	return g_Decoratives.bushMedium;
 }
 
 function rBiomeA8()
 {
 	return g_Decoratives.bushSmall;
 }
 
 function rBiomeA9()
 {
 	return g_Decoratives.tree;
 }
Index: ps/trunk/binaries/data/mods/public/maps/random/snowflake_searocks.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/snowflake_searocks.js	(revision 19285)
+++ ps/trunk/binaries/data/mods/public/maps/random/snowflake_searocks.js	(revision 19286)
@@ -1,1900 +1,1893 @@
 RMS.LoadLibrary("rmgen");
 
 //random terrain textures
 var random_terrain = randomizeBiome();
 
 const tMainTerrain = rBiomeT1();
 const tForestFloor1 = rBiomeT2();
 const tForestFloor2 = rBiomeT3();
 const tCliff = rBiomeT4();
 const tTier1Terrain = rBiomeT5();
 const tTier2Terrain = rBiomeT6();
 const tTier3Terrain = rBiomeT7();
 const tHill = rBiomeT1();
 const tDirt = rBiomeT9();
 const tRoad = rBiomeT10();
 const tRoadWild = rBiomeT11();
 const tTier4Terrain = rBiomeT12();
 const tShoreBlend = rBiomeT13();
 const tShore = rBiomeT14();
 const tWater = rBiomeT15();
 
 // gaia entities
 const oTree1 = rBiomeE1();
 const oTree2 = rBiomeE2();
 const oTree3 = rBiomeE3();
 const oTree4 = rBiomeE4();
 const oTree5 = rBiomeE5();
 const oFruitBush = rBiomeE6();
 const oMainHuntableAnimal = rBiomeE8();
 const oFish = rBiomeE9();
 const oSecondaryHuntableAnimal = rBiomeE10();
 const oStoneLarge = rBiomeE11();
 const oStoneSmall = rBiomeE12();
 const oMetalLarge = rBiomeE13();
 
 // decorative props
 const aGrass = rBiomeA1();
 const aGrassShort = rBiomeA2();
 const aReeds = rBiomeA3();
 const aLillies = rBiomeA4();
 const aRockLarge = rBiomeA5();
 const aRockMedium = rBiomeA6();
 const aBushMedium = rBiomeA7();
 const aBushSmall = rBiomeA8();
 
 const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
 const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
 
 log("Initializing map...");
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 const mapArea = mapSize*mapSize;
 
 log(mapSize);
 
 // create tile classes
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clSettlement = createTileClass();
 var clLand = createTileClass();
 
 //Paint the whole map
 
 for (var ix = 0; ix < mapSize; ix++)
 {
 	for (var iz = 0; iz < mapSize; iz++)
 	{
 		var x = ix / (mapSize + 1.0);
 		var z = iz / (mapSize + 1.0);
 			placeTerrain(ix, iz, tWater);
 	}
 }
 
 const radius = scaleByMapSize(15,30);
 const cliffRadius = 2;
 const elevation = 20;
 // randomize player order
 
 var playerIDs = [];
 for (var i = 0; i < numPlayers; i++)
 {
 	playerIDs.push(i+1);
 }
 playerIDs = sortPlayers(playerIDs);
 
 // place players
 
 var playerX = new Array(numPlayers);
 var playerZ = new Array(numPlayers);
 var playerAngle = new Array(numPlayers);
 
 var startAngle = randFloat(0, TWO_PI);
 for (var i = 0; i < numPlayers; i++)
 {
 	playerAngle[i] = startAngle + i*TWO_PI/numPlayers;
 	playerX[i] = 0.5 + 0.35*cos(playerAngle[i]);
 	playerZ[i] = 0.5 + 0.35*sin(playerAngle[i]);
 }
 
 // Creating other islands
 var numIslands = 0;
 //****************************
 //----------------------------
 //Tiny and Small Size
 //----------------------------
 //****************************
 if ((mapSize == 128)||(mapSize == 192)){
 		//2 PLAYERS
 		//-----------------
 		//-----------------
 	if (numPlayers == 2){
 		numIslands = 4*numPlayers+1;
 		var IslandX = new Array(numIslands);
 		var IslandZ = new Array(numIslands);
 		var isConnected = new Array(numIslands);
 		for (var q=0; q <numIslands; q++)
 		{
 			isConnected[q]=new Array(numIslands);
 		}
 		for (var m = 0; m < numIslands; m++){
 			for (var n = 0; n < numIslands; n++){
 				isConnected[m][n] = 0;
 			}
 		}
 		//connections
 		var sX = 0;
 		var sZ = 0;
 		for (var l = 0; l < numPlayers; l++)
 		{
 			isConnected[4*numPlayers][l+2*numPlayers] = 1;
 			sX = sX + playerX[l];
 			sZ = sZ + playerZ[l];
 		}
 
 		var fx = fractionToTiles(sX/numPlayers);
 		var fz = fractionToTiles(sZ/numPlayers);
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[4*numPlayers]=ix;
 		IslandZ[4*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.36);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		//centeral island id numPlayers
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 		isConnected[e+2*numPlayers][e] = 1;
 		if (e+2*numPlayers+1<numIslands-numPlayers-1)
 		{
 			isConnected[e+2*numPlayers][e+2*numPlayers+1] = 1;
 		}
 		else
 		{
 			isConnected[2*numPlayers][e+2*numPlayers] = 1;
 		}
 
 		var fx = fractionToTiles(0.5 + 0.16*cos(startAngle + e*TWO_PI/numPlayers));
 		var fz = fractionToTiles(0.5 + 0.16*sin(startAngle + e*TWO_PI/numPlayers));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+2*numPlayers]=ix;
 		IslandZ[e+2*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.81);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 		//Small Isles
 		isConnected[e+3*numPlayers][e+numPlayers] = 1;
 		var fx = fractionToTiles(0.5 + 0.27*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var fz = fractionToTiles(0.5 + 0.27*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+3*numPlayers]=ix;
 		IslandZ[e+3*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.49);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 			isConnected[e][e+numPlayers] = 1;
 			if (e+1<numPlayers)
 			{
 				isConnected[e + 1][e+numPlayers] = 1;
 			}
 			else
 			{
 				isConnected[0][e+numPlayers] = 1;
 			}
 
 			//second island id 4
 			var fx = fractionToTiles(0.5 + 0.41*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var fz = fractionToTiles(0.5 + 0.41*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var ix = round(fx);
 			var iz = round(fz);
 			IslandX[e+numPlayers]=ix;
 			IslandZ[e+numPlayers]=iz;
 			// calculate size based on the radius
 			var hillSize = PI * radius * radius;
 
 			// create the hill
 			var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 			var terrainPainter = new LayeredPainter(
 				[tCliff, tHill],		// terrains
 				[cliffRadius]		// widths
 			);
 			var elevationPainter = new SmoothElevationPainter(
 				ELEVATION_SET,			// type
 				elevation,				// elevation
 				cliffRadius				// blend radius
 			);
 			createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 	}
 		//3 PLAYERS
 		//-----------------
 		//-----------------
 		if (numPlayers == 3){
 		numIslands = 4*numPlayers+1;
 		var IslandX = new Array(numIslands);
 		var IslandZ = new Array(numIslands);
 		var isConnected = new Array(numIslands);
 		for (var q=0; q <numIslands; q++)
 		{
 			isConnected[q]=new Array(numIslands);
 		}
 		for (var m = 0; m < numIslands; m++){
 			for (var n = 0; n < numIslands; n++){
 				isConnected[m][n] = 0;
 			}
 		}
 		//connections
 		var sX = 0;
 		var sZ = 0;
 		for (var l = 0; l < numPlayers; l++)
 		{
 			isConnected[4*numPlayers][l+2*numPlayers] = 1;
 			sX = sX + playerX[l];
 			sZ = sZ + playerZ[l];
 		}
 
 		var fx = fractionToTiles(sX/numPlayers);
 		var fz = fractionToTiles(sZ/numPlayers);
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[4*numPlayers]=ix;
 		IslandZ[4*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.36);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		//centeral island id numPlayers
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 		isConnected[e+2*numPlayers][e] = 1;
 		if (e+2*numPlayers+1<numIslands-numPlayers-1)
 		{
 			isConnected[e+2*numPlayers][e+2*numPlayers+1] = 1;
 		}
 		else
 		{
 			isConnected[2*numPlayers][e+2*numPlayers] = 1;
 		}
 
 		var fx = fractionToTiles(0.5 + 0.16*cos(startAngle + e*TWO_PI/numPlayers));
 		var fz = fractionToTiles(0.5 + 0.16*sin(startAngle + e*TWO_PI/numPlayers));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+2*numPlayers]=ix;
 		IslandZ[e+2*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.81);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 		//Small Isles
 		isConnected[e+3*numPlayers][e+numPlayers] = 1;
 		var fx = fractionToTiles(0.5 + 0.27*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var fz = fractionToTiles(0.5 + 0.27*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+3*numPlayers]=ix;
 		IslandZ[e+3*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.49);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 			isConnected[e][e+numPlayers] = 1;
 			if (e+1<numPlayers)
 			{
 				isConnected[e + 1][e+numPlayers] = 1;
 			}
 			else
 			{
 				isConnected[0][e+numPlayers] = 1;
 			}
 
 			//second island id 4
 			var fx = fractionToTiles(0.5 + 0.41*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var fz = fractionToTiles(0.5 + 0.41*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var ix = round(fx);
 			var iz = round(fz);
 			IslandX[e+numPlayers]=ix;
 			IslandZ[e+numPlayers]=iz;
 			// calculate size based on the radius
 			var hillSize = PI * radius * radius;
 
 			// create the hill
 			var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 			var terrainPainter = new LayeredPainter(
 				[tCliff, tHill],		// terrains
 				[cliffRadius]		// widths
 			);
 			var elevationPainter = new SmoothElevationPainter(
 				ELEVATION_SET,			// type
 				elevation,				// elevation
 				cliffRadius				// blend radius
 			);
 			createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 	}
 
 		//4 PLAYERS
 		//-----------------
 		//-----------------
 		if (numPlayers == 4){
 		numIslands = 4*numPlayers+1;
 		var IslandX = new Array(numIslands);
 		var IslandZ = new Array(numIslands);
 		var isConnected = new Array(numIslands);
 		for (var q=0; q <numIslands; q++)
 		{
 			isConnected[q]=new Array(numIslands);
 		}
 		for (var m = 0; m < numIslands; m++){
 			for (var n = 0; n < numIslands; n++){
 				isConnected[m][n] = 0;
 			}
 		}
 		//connections
 		var sX = 0;
 		var sZ = 0;
 		for (var l = 0; l < numPlayers; l++)
 		{
 			isConnected[4*numPlayers][l+2*numPlayers] = 1;
 			sX = sX + playerX[l];
 			sZ = sZ + playerZ[l];
 		}
 
 		var fx = fractionToTiles(sX/numPlayers);
 		var fz = fractionToTiles(sZ/numPlayers);
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[4*numPlayers]=ix;
 		IslandZ[4*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.36);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		//centeral island id numPlayers
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 		isConnected[e+2*numPlayers][e] = 1;
 		if (e+2*numPlayers+1<numIslands-numPlayers-1)
 		{
 			isConnected[e+2*numPlayers][e+2*numPlayers+1] = 1;
 		}
 		else
 		{
 			isConnected[2*numPlayers][e+2*numPlayers] = 1;
 		}
 
 		var fx = fractionToTiles(0.5 + 0.16*cos(startAngle + e*TWO_PI/numPlayers));
 		var fz = fractionToTiles(0.5 + 0.16*sin(startAngle + e*TWO_PI/numPlayers));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+2*numPlayers]=ix;
 		IslandZ[e+2*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.81);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 		//Small Isles
 		isConnected[e+3*numPlayers][e+numPlayers] = 1;
 		var fx = fractionToTiles(0.5 + 0.41*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var fz = fractionToTiles(0.5 + 0.41*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+3*numPlayers]=ix;
 		IslandZ[e+3*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.49);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 			isConnected[e][e+numPlayers] = 1;
 			if (e+1<numPlayers)
 			{
 				isConnected[e + 1][e+numPlayers] = 1;
 			}
 			else
 			{
 				isConnected[0][e+numPlayers] = 1;
 			}
 
 			//second island id 4
 			var fx = fractionToTiles(0.5 + 0.27*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var fz = fractionToTiles(0.5 + 0.27*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var ix = round(fx);
 			var iz = round(fz);
 			IslandX[e+numPlayers]=ix;
 			IslandZ[e+numPlayers]=iz;
 			// calculate size based on the radius
 			var hillSize = PI * radius * radius;
 
 			// create the hill
 			var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 			var terrainPainter = new LayeredPainter(
 				[tCliff, tHill],		// terrains
 				[cliffRadius]		// widths
 			);
 			var elevationPainter = new SmoothElevationPainter(
 				ELEVATION_SET,			// type
 				elevation,				// elevation
 				cliffRadius				// blend radius
 			);
 			createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 	}
 
 			//More than 4 PLAYERS
 		//-----------------
 		//-----------------
 		if (numPlayers > 4){
 		numIslands = numPlayers + 1;
 		var IslandX = new Array(numIslands);
 		var IslandZ = new Array(numIslands);
 		var isConnected = new Array(numIslands);
 		for (var q=0; q <numIslands; q++)
 		{
 			isConnected[q]=new Array(numIslands);
 		}
 		for (var m = 0; m < numIslands; m++){
 			for (var n = 0; n < numIslands; n++){
 				isConnected[m][n] = 0;
 			}
 		}
 		//connections
 		var sX = 0;
 		var sZ = 0;
 		for (var l = 0; l < numPlayers; l++)
 		{
 			isConnected[l][numPlayers] = 1;
 			sX = sX + playerX[l];
 			sZ = sZ + playerZ[l];
 		}
 
 		//centeral island id numPlayers
 
 		var fx = fractionToTiles((sX)/numPlayers);
 		var fz = fractionToTiles((sZ)/numPlayers);
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[numPlayers]=ix;
 		IslandZ[numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = PI * radius * radius;
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 
 	}
 }
 
 //****************************
 //----------------------------
 //Medium Size
 //----------------------------
 //****************************
 if (mapSize == 256){
 		//2,3,4 PLAYERS
 		//-----------------
 		//-----------------
 		if ((numPlayers == 2)||(numPlayers == 3)||(numPlayers == 4)){
 		numIslands = 4*numPlayers+1;
 		var IslandX = new Array(numIslands);
 		var IslandZ = new Array(numIslands);
 		var isConnected = new Array(numIslands);
 		for (var q=0; q <numIslands; q++)
 		{
 			isConnected[q]=new Array(numIslands);
 		}
 		for (var m = 0; m < numIslands; m++){
 			for (var n = 0; n < numIslands; n++){
 				isConnected[m][n] = 0;
 			}
 		}
 		//connections
 		var sX = 0;
 		var sZ = 0;
 		for (var l = 0; l < numPlayers; l++)
 		{
 			isConnected[4*numPlayers][l+2*numPlayers] = 1;
 			sX = sX + playerX[l];
 			sZ = sZ + playerZ[l];
 		}
 
 		var fx = fractionToTiles(sX/numPlayers);
 		var fz = fractionToTiles(sZ/numPlayers);
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[4*numPlayers]=ix;
 		IslandZ[4*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.36);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		//centeral island id numPlayers
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 		isConnected[e+2*numPlayers][e] = 1;
 		if (e+2*numPlayers+1<numIslands-numPlayers-1)
 		{
 			isConnected[e+2*numPlayers][e+2*numPlayers+1] = 1;
 		}
 		else
 		{
 			isConnected[2*numPlayers][e+2*numPlayers] = 1;
 		}
 
 		var fx = fractionToTiles(0.5 + 0.16*cos(startAngle + e*TWO_PI/numPlayers));
 		var fz = fractionToTiles(0.5 + 0.16*sin(startAngle + e*TWO_PI/numPlayers));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+2*numPlayers]=ix;
 		IslandZ[e+2*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.81);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 		//Small Isles
 		isConnected[e+3*numPlayers][e+numPlayers] = 1;
 		var fx = fractionToTiles(0.5 + 0.41*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var fz = fractionToTiles(0.5 + 0.41*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+3*numPlayers]=ix;
 		IslandZ[e+3*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.49);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 			isConnected[e][e+numPlayers] = 1;
 			if (e+1<numPlayers)
 			{
 				isConnected[e + 1][e+numPlayers] = 1;
 			}
 			else
 			{
 				isConnected[0][e+numPlayers] = 1;
 			}
 
 			//second island id 4
 			var fx = fractionToTiles(0.5 + 0.26*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var fz = fractionToTiles(0.5 + 0.26*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var ix = round(fx);
 			var iz = round(fz);
 			IslandX[e+numPlayers]=ix;
 			IslandZ[e+numPlayers]=iz;
 			// calculate size based on the radius
 			var hillSize = PI * radius * radius;
 
 			// create the hill
 			var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 			var terrainPainter = new LayeredPainter(
 				[tCliff, tHill],		// terrains
 				[cliffRadius]		// widths
 			);
 			var elevationPainter = new SmoothElevationPainter(
 				ELEVATION_SET,			// type
 				elevation,				// elevation
 				cliffRadius				// blend radius
 			);
 			createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 	}
 
 			//More than 4 PLAYERS
 		//-----------------
 		//-----------------
 		if (numPlayers > 4){
 		numIslands = 2*numPlayers;
 		var IslandX = new Array(numIslands);
 		var IslandZ = new Array(numIslands);
 		var isConnected = new Array(numIslands);
 		for (var q=0; q <numIslands; q++)
 		{
 			isConnected[q]=new Array(numIslands);
 		}
 		for (var m = 0; m < numIslands; m++){
 			for (var n = 0; n < numIslands; n++){
 				isConnected[m][n] = 0;
 			}
 		}
 		//connections
 		var sX = 0;
 		var sZ = 0;
 
 
 
 		//centeral island id numPlayers
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 		if (e+1<numPlayers)
 		{
 			isConnected[e][e+1] = 1;
 		}
 		else
 		{
 			isConnected[0][e] = 1;
 		}
 		isConnected[e+numPlayers][e] = 1;
 		if (e+numPlayers+1<numIslands)
 		{
 			isConnected[e+numPlayers][e+numPlayers+1] = 1;
 		}
 		else
 		{
 			isConnected[e+numPlayers][numPlayers] = 1;
 		}
 		var fx = fractionToTiles(0.5 + 0.16*cos(startAngle + e*TWO_PI/numPlayers));
 		var fz = fractionToTiles(0.5 + 0.16*sin(startAngle + e*TWO_PI/numPlayers));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+numPlayers]=ix;
 		IslandZ[e+numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.81);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 
 	}
 }
 
 //****************************
 //----------------------------
 //Normal Size
 //----------------------------
 //****************************
 if (mapSize == 320){
 		//2,3,4,5 PLAYERS
 		//-----------------
 		//-----------------
 		if ((numPlayers == 2)||(numPlayers == 3)||(numPlayers == 4)||(numPlayers == 5)){
 		numIslands = 4*numPlayers+1;
 		var IslandX = new Array(numIslands);
 		var IslandZ = new Array(numIslands);
 		var isConnected = new Array(numIslands);
 		for (var q=0; q <numIslands; q++)
 		{
 			isConnected[q]=new Array(numIslands);
 		}
 		for (var m = 0; m < numIslands; m++){
 			for (var n = 0; n < numIslands; n++){
 				isConnected[m][n] = 0;
 			}
 		}
 		//connections
 		var sX = 0;
 		var sZ = 0;
 		for (var l = 0; l < numPlayers; l++)
 		{
 			isConnected[4*numPlayers][l+2*numPlayers] = 1;
 			sX = sX + playerX[l];
 			sZ = sZ + playerZ[l];
 		}
 
 		var fx = fractionToTiles(sX/numPlayers);
 		var fz = fractionToTiles(sZ/numPlayers);
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[4*numPlayers]=ix;
 		IslandZ[4*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.36);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		//centeral island id numPlayers
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 		isConnected[e+2*numPlayers][e] = 1;
 		if (e+2*numPlayers+1<numIslands-numPlayers-1)
 		{
 			isConnected[e+2*numPlayers][e+2*numPlayers+1] = 1;
 		}
 		else
 		{
 			isConnected[2*numPlayers][e+2*numPlayers] = 1;
 		}
 
 		var fx = fractionToTiles(0.5 + 0.16*cos(startAngle + e*TWO_PI/numPlayers));
 		var fz = fractionToTiles(0.5 + 0.16*sin(startAngle + e*TWO_PI/numPlayers));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+2*numPlayers]=ix;
 		IslandZ[e+2*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.81);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 		//Small Isles
 		isConnected[e+3*numPlayers][e+numPlayers] = 1;
 		var fx = fractionToTiles(0.5 + 0.41*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var fz = fractionToTiles(0.5 + 0.41*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+3*numPlayers]=ix;
 		IslandZ[e+3*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.49);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 			isConnected[e][e+numPlayers] = 1;
 			if (e+1<numPlayers)
 			{
 				isConnected[e + 1][e+numPlayers] = 1;
 			}
 			else
 			{
 				isConnected[0][e+numPlayers] = 1;
 			}
 
 			//second island id 4
 			var fx = fractionToTiles(0.5 + 0.26*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var fz = fractionToTiles(0.5 + 0.26*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var ix = round(fx);
 			var iz = round(fz);
 			IslandX[e+numPlayers]=ix;
 			IslandZ[e+numPlayers]=iz;
 			// calculate size based on the radius
 			var hillSize = PI * radius * radius;
 
 			// create the hill
 			var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 			var terrainPainter = new LayeredPainter(
 				[tCliff, tHill],		// terrains
 				[cliffRadius]		// widths
 			);
 			var elevationPainter = new SmoothElevationPainter(
 				ELEVATION_SET,			// type
 				elevation,				// elevation
 				cliffRadius				// blend radius
 			);
 			createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 	}
 
 		//6,7 PLAYERS
 		//-----------------
 		//-----------------
 		if ((numPlayers == 6)||(numPlayers == 7)){
 		numIslands = 4*numPlayers+1;
 		var IslandX = new Array(numIslands);
 		var IslandZ = new Array(numIslands);
 		var isConnected = new Array(numIslands);
 		for (var q=0; q <numIslands; q++)
 		{
 			isConnected[q]=new Array(numIslands);
 		}
 		for (var m = 0; m < numIslands; m++){
 			for (var n = 0; n < numIslands; n++){
 				isConnected[m][n] = 0;
 			}
 		}
 		//connections
 		var sX = 0;
 		var sZ = 0;
 		for (var l = 0; l < numPlayers; l++)
 		{
 			isConnected[4*numPlayers][l+2*numPlayers] = 1;
 			sX = sX + playerX[l];
 			sZ = sZ + playerZ[l];
 		}
 
 		var fx = fractionToTiles(sX/numPlayers);
 		var fz = fractionToTiles(sZ/numPlayers);
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[4*numPlayers]=ix;
 		IslandZ[4*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.36);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		//centeral island id numPlayers
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 		isConnected[e+2*numPlayers][e] = 1;
 		if (e+2*numPlayers+1<numIslands-numPlayers-1)
 		{
 			isConnected[e+2*numPlayers][e+2*numPlayers+1] = 1;
 		}
 		else
 		{
 			isConnected[2*numPlayers][e+2*numPlayers] = 1;
 		}
 
 		var fx = fractionToTiles(0.5 + 0.16*cos(startAngle + e*TWO_PI/numPlayers));
 		var fz = fractionToTiles(0.5 + 0.16*sin(startAngle + e*TWO_PI/numPlayers));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+2*numPlayers]=ix;
 		IslandZ[e+2*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.81);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 		//Small Isles
 		isConnected[e+3*numPlayers][e+numPlayers] = 1;
 		var fx = fractionToTiles(0.5 + 0.41*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var fz = fractionToTiles(0.5 + 0.41*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+3*numPlayers]=ix;
 		IslandZ[e+3*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.49);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 			isConnected[e][e+numPlayers] = 1;
 			if (e+1<numPlayers)
 			{
 				isConnected[e + 1][e+numPlayers] = 1;
 			}
 			else
 			{
 				isConnected[0][e+numPlayers] = 1;
 			}
 
 			//second island id 4
 			var fx = fractionToTiles(0.5 + 0.26*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var fz = fractionToTiles(0.5 + 0.26*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var ix = round(fx);
 			var iz = round(fz);
 			IslandX[e+numPlayers]=ix;
 			IslandZ[e+numPlayers]=iz;
 			// calculate size based on the radius
 			var hillSize = PI * radius * radius;
 
 			// create the hill
 			var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 			var terrainPainter = new LayeredPainter(
 				[tCliff, tHill],		// terrains
 				[cliffRadius]		// widths
 			);
 			var elevationPainter = new SmoothElevationPainter(
 				ELEVATION_SET,			// type
 				elevation,				// elevation
 				cliffRadius				// blend radius
 			);
 			createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 	}
 		//8 PLAYERS
 		//-----------------
 		//-----------------
 		if (numPlayers == 8){
 		numIslands = 2*numPlayers;
 		var IslandX = new Array(numIslands);
 		var IslandZ = new Array(numIslands);
 		var isConnected = new Array(numIslands);
 		for (var q=0; q <numIslands; q++)
 		{
 			isConnected[q]=new Array(numIslands);
 		}
 		for (var m = 0; m < numIslands; m++){
 			for (var n = 0; n < numIslands; n++){
 				isConnected[m][n] = 0;
 			}
 		}
 		//connections
 		var sX = 0;
 		var sZ = 0;
 
 
 
 		//centeral island id numPlayers
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 		if (e+1<numPlayers)
 		{
 			isConnected[e][e+1] = 1;
 		}
 		else
 		{
 			isConnected[0][e] = 1;
 		}
 		isConnected[e+numPlayers][e] = 1;
 		if (e+numPlayers+1<numIslands)
 		{
 			isConnected[e+numPlayers][e+numPlayers+1] = 1;
 		}
 		else
 		{
 			isConnected[e+numPlayers][numPlayers] = 1;
 		}
 		var fx = fractionToTiles(0.5 + 0.16*cos(startAngle + e*TWO_PI/numPlayers));
 		var fz = fractionToTiles(0.5 + 0.16*sin(startAngle + e*TWO_PI/numPlayers));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+numPlayers]=ix;
 		IslandZ[e+numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.81);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 
 	}
 }
 
 //****************************
 //----------------------------
 //Large and larger Sizes
 //----------------------------
 //****************************
 if (mapSize > 383){
 		//2,3,4,5 PLAYERS
 		//-----------------
 		//-----------------
 		if ((numPlayers == 2)||(numPlayers == 3)||(numPlayers == 4)||(numPlayers == 5)){
 		numIslands = 4*numPlayers+1;
 		var IslandX = new Array(numIslands);
 		var IslandZ = new Array(numIslands);
 		var isConnected = new Array(numIslands);
 		for (var q=0; q <numIslands; q++)
 		{
 			isConnected[q]=new Array(numIslands);
 		}
 		for (var m = 0; m < numIslands; m++){
 			for (var n = 0; n < numIslands; n++){
 				isConnected[m][n] = 0;
 			}
 		}
 		//connections
 		var sX = 0;
 		var sZ = 0;
 		for (var l = 0; l < numPlayers; l++)
 		{
 			isConnected[4*numPlayers][l+2*numPlayers] = 1;
 			sX = sX + playerX[l];
 			sZ = sZ + playerZ[l];
 		}
 
 		var fx = fractionToTiles(sX/numPlayers);
 		var fz = fractionToTiles(sZ/numPlayers);
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[4*numPlayers]=ix;
 		IslandZ[4*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.36);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		//centeral island id numPlayers
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 		isConnected[e+2*numPlayers][e] = 1;
 		if (e+2*numPlayers+1<numIslands-numPlayers-1)
 		{
 			isConnected[e+2*numPlayers][e+2*numPlayers+1] = 1;
 		}
 		else
 		{
 			isConnected[2*numPlayers][e+2*numPlayers] = 1;
 		}
 
 		var fx = fractionToTiles(0.5 + 0.16*cos(startAngle + e*TWO_PI/numPlayers));
 		var fz = fractionToTiles(0.5 + 0.16*sin(startAngle + e*TWO_PI/numPlayers));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+2*numPlayers]=ix;
 		IslandZ[e+2*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.81);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 		//Small Isles
 		isConnected[e+3*numPlayers][e+numPlayers] = 1;
 		var fx = fractionToTiles(0.5 + 0.41*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var fz = fractionToTiles(0.5 + 0.41*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+3*numPlayers]=ix;
 		IslandZ[e+3*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.49);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 			isConnected[e][e+numPlayers] = 1;
 			if (e+1<numPlayers)
 			{
 				isConnected[e + 1][e+numPlayers] = 1;
 			}
 			else
 			{
 				isConnected[0][e+numPlayers] = 1;
 			}
 
 			//second island id 4
 			var fx = fractionToTiles(0.5 + 0.24*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var fz = fractionToTiles(0.5 + 0.24*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var ix = round(fx);
 			var iz = round(fz);
 			IslandX[e+numPlayers]=ix;
 			IslandZ[e+numPlayers]=iz;
 			// calculate size based on the radius
 			var hillSize = PI * radius * radius;
 
 			// create the hill
 			var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 			var terrainPainter = new LayeredPainter(
 				[tCliff, tHill],		// terrains
 				[cliffRadius]		// widths
 			);
 			var elevationPainter = new SmoothElevationPainter(
 				ELEVATION_SET,			// type
 				elevation,				// elevation
 				cliffRadius				// blend radius
 			);
 			createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 
 	}
 
 		//6,7,8 PLAYERS
 		//-----------------
 		//-----------------
 		if ((numPlayers == 6)||(numPlayers == 7)||(numPlayers == 8)){
 		numIslands = 4*numPlayers+1;
 		var IslandX = new Array(numIslands);
 		var IslandZ = new Array(numIslands);
 		var isConnected = new Array(numIslands);
 		for (var q=0; q <numIslands; q++)
 		{
 			isConnected[q]=new Array(numIslands);
 		}
 		for (var m = 0; m < numIslands; m++){
 			for (var n = 0; n < numIslands; n++){
 				isConnected[m][n] = 0;
 			}
 		}
 		//connections
 		var sX = 0;
 		var sZ = 0;
 		for (var l = 0; l < numPlayers; l++)
 		{
 			isConnected[4*numPlayers][l+2*numPlayers] = 1;
 			sX = sX + playerX[l];
 			sZ = sZ + playerZ[l];
 		}
 
 		var fx = fractionToTiles(sX/numPlayers);
 		var fz = fractionToTiles(sZ/numPlayers);
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[4*numPlayers]=ix;
 		IslandZ[4*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.36);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 
 
 		//centeral island id numPlayers
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 		isConnected[e+2*numPlayers][e] = 1;
 		if (e+2*numPlayers+1<numIslands-numPlayers-1)
 		{
 			isConnected[e+2*numPlayers][e+2*numPlayers+1] = 1;
 		}
 		else
 		{
 			isConnected[2*numPlayers][e+2*numPlayers] = 1;
 		}
 
 		var fx = fractionToTiles(0.5 + 0.16*cos(startAngle + e*TWO_PI/numPlayers));
 		var fz = fractionToTiles(0.5 + 0.16*sin(startAngle + e*TWO_PI/numPlayers));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+2*numPlayers]=ix;
 		IslandZ[e+2*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.81);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 		//Small Isles
 		isConnected[e+3*numPlayers][e+numPlayers] = 1;
 		var fx = fractionToTiles(0.5 + 0.41*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var fz = fractionToTiles(0.5 + 0.41*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+3*numPlayers]=ix;
 		IslandZ[e+3*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.36);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 			isConnected[e][e+numPlayers] = 1;
 			if (e+1<numPlayers)
 			{
 				isConnected[e + 1][e+numPlayers] = 1;
 			}
 			else
 			{
 				isConnected[0][e+numPlayers] = 1;
 			}
 
 			//second island id 4
 			var fx = fractionToTiles(0.5 + 0.28*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var fz = fractionToTiles(0.5 + 0.28*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var ix = round(fx);
 			var iz = round(fz);
 			IslandX[e+numPlayers]=ix;
 			IslandZ[e+numPlayers]=iz;
 			// calculate size based on the radius
 			var hillSize = PI * radius * radius * 0.81;
 
 			// create the hill
 			var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 			var terrainPainter = new LayeredPainter(
 				[tCliff, tHill],		// terrains
 				[cliffRadius]		// widths
 			);
 			var elevationPainter = new SmoothElevationPainter(
 				ELEVATION_SET,			// type
 				elevation,				// elevation
 				cliffRadius				// blend radius
 			);
 			createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 
 	}
 }
 
 for (var m = 0; m < numIslands; m++){
 	for (var n = 0; n < numIslands; n++){
 		if(isConnected[m][n] == 1){
 			isConnected[n][m] = 1;
 		}
 	}
 }
 
 
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	// some constants
 
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 		IslandX[i]=ix;
 		IslandZ[i]=iz;
 	// calculate size based on the radius
 	var hillSize = PI * radius * radius;
 
 	// create the hill
 	var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 	var terrainPainter = new LayeredPainter(
 		[tCliff, tHill],		// terrains
 		[cliffRadius]		// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		elevation,				// elevation
 		cliffRadius				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clPlayer)], null);
 
 
 	// create the city patch
 	var cityRadius = radius/3;
 	placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tRoadWild, tRoad], [1]);
 	createArea(placer, painter, null);
 
 	// create starting units
 	placeCivDefaultEntities(fx, fz, id, { 'iberWall': 'towers' });
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 10;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oFruitBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = radius - 4;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var num = floor(hillSize / 60);
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = 11;
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oTree1, num, num, 0,4)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, [avoidClasses(clBaseResource,2), stayClasses(clPlayer, 3)]);
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 
 RMS.SetProgress(30);
 
 //Create connectors
 for (var ix = 0; ix < mapSize; ix++)
 {
 	for (var iz = 0; iz < mapSize; iz++)
 	{
 		for (var m = 0; m < numIslands; m++)
 		{
 			for (var n = 0; n < numIslands; n++)
 			{
 				if(isConnected[m][n] == 1)
 				{
 					var a = IslandZ[m]-IslandZ[n];
 					var b = IslandX[n]-IslandX[m];
 					var c = (IslandZ[m]*(IslandX[m]-IslandX[n]))-(IslandX[m]*(IslandZ[m]-IslandZ[n]));
 					var dis = abs(a*ix + b*iz + c)/sqrt(a*a + b*b);
 					var k = (a*ix + b*iz + c)/(a*a + b*b);
 					var y = iz-(b*k);
 					if((dis < 5)&&(y <= Math.max(IslandZ[m],IslandZ[n]))&&(y >= Math.min(IslandZ[m],IslandZ[n])))
 					{
 						if (dis < 3){
 							var h = 20;
 							if (dis < 2)
 							{
 								var t = tHill;
 							}
 							else
 							{
 								var t = tCliff;
 							}
 							addToClass(ix, iz, clLand);
 						}
 						else
 						{
 							var h = 50 - 10 * dis;
 							var t = tCliff;
 							addToClass(ix, iz, clLand);
 						}
 						if (getHeight(ix, iz)<h)
 						{
 							placeTerrain(ix, iz, t);
 							setHeight(ix, iz, h);
 						}
 					}
 				}
 			}
 		}
 	}
 }
 
 // calculate desired number of trees for map (based on size)
 if (random_terrain == g_BiomeSavanna)
 {
 	var MIN_TREES = 200;
 	var MAX_TREES = 1250;
 	var P_FOREST = 0.02;
 }
 else if (random_terrain == g_BiomeTropic)
 {
 	var MIN_TREES = 1000;
 	var MAX_TREES = 6000;
 	var P_FOREST = 0.6;
 }
 else
 {
 	var MIN_TREES = 500;
 	var MAX_TREES = 3000;
 	var P_FOREST = 0.7;
 }
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 var numForest = totalTrees * P_FOREST;
 var numStragglers = totalTrees * (1.0 - P_FOREST);
 
 // create forests
 log("Creating forests...");
 var types = [
 	[[tForestFloor2, tMainTerrain, pForest1], [tForestFloor2, pForest1]],
 	[[tForestFloor1, tMainTerrain, pForest2], [tForestFloor1, pForest2]]
 ];	// some variation
 
 if (random_terrain == g_BiomeSavanna)
 	var size = numForest / (0.5 * scaleByMapSize(2,8) * numPlayers);
 else
 	var size = numForest / (scaleByMapSize(2,8) * numPlayers);
 
 var num = floor(size / types.length);
 for (var i = 0; i < types.length; ++i)
 {
 	placer = new ClumpPlacer(numForest / num, 0.1, 0.1, 1);
 	painter = new LayeredPainter(
 		types[i],		// terrains
 		[2]											// widths
 		);
 	createAreas(
 		placer,
 		[painter, paintClass(clForest)],
 		[avoidClasses(clPlayer, 6, clForest, 10, clHill, 0), stayClasses(clLand, 4)],
 		num
 	);
 }
 
 RMS.SetProgress(55);
 
 
 log("Creating stone mines...");
 // create large stone quarries
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
 createObjectGroups(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 10, clRock, 10, clHill, 1), stayClasses(clLand, 5)],
 	5*scaleByMapSize(4,16), 100
 );
 
 // create small stone quarries
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroups(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 10, clRock, 10, clHill, 1), stayClasses(clLand, 5)],
 	5*scaleByMapSize(4,16), 100
 );
 
 log("Creating metal mines...");
 // create large metal quarries
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroups(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 10, clMetal, 10, clRock, 5, clHill, 1), stayClasses(clLand, 5)],
 	5*scaleByMapSize(4,16), 100
 );
 
 RMS.SetProgress(65);
 // create dirt patches
 log("Creating dirt patches...");
 var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
 for (var i = 0; i < sizes.length; i++)
 {
 	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
 	painter = new LayeredPainter(
 		[[tMainTerrain,tTier1Terrain],[tTier1Terrain,tTier2Terrain], [tTier2Terrain,tTier3Terrain]], 		// terrains
 		[1,1]															// widths
 	);
 	createAreas(
 		placer,
 		[painter, paintClass(clDirt)],
 		[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12), stayClasses(clLand, 5)],
 		scaleByMapSize(15, 45)
 	);
 }
 
 // create grass patches
 log("Creating grass patches...");
 var sizes = [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)];
 for (var i = 0; i < sizes.length; i++)
 {
 	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
 	painter = new TerrainPainter(tTier4Terrain);
 	createAreas(
 		placer,
 		painter,
 		[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12), stayClasses(clLand, 5)],
 		scaleByMapSize(15, 45)
 	);
 }
 
 // create small decorative rocks
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockMedium, 1,3, 0,1)],
 	true
 );
 createObjectGroups(
 	group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 4)],
 	scaleByMapSize(16, 262), 50
 );
 
 
 // create large decorative rocks
 log("Creating large decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
 	true
 );
 createObjectGroups(
 	group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 4)],
 	scaleByMapSize(8, 131), 50
 );
 
 RMS.SetProgress(70);
 
 // create deer
 log("Creating deer...");
 group = new SimpleGroup(
 	[new SimpleObject(oMainHuntableAnimal, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 10, clHill, 1, clFood, 20), stayClasses(clLand, 4)],
 	3 * numPlayers, 50
 );
 
 RMS.SetProgress(75);
 
 // create sheep
 log("Creating sheep...");
 group = new SimpleGroup(
 	[new SimpleObject(oSecondaryHuntableAnimal, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 10, clHill, 1, clFood, 20), stayClasses(clLand, 4)],
 	3 * numPlayers, 50
 );
 
 // create fruits
 log("Creating fruits...");
 group = new SimpleGroup(
 	[new SimpleObject(oFruitBush, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 10, clHill, 1, clFood, 20), stayClasses(clLand, 4)],
 	3 * numPlayers, 50
 );
 
 RMS.SetProgress(85);
 
 
 // create straggler trees
 log("Creating straggler trees...");
 var types = [oTree1, oTree2, oTree4, oTree3];	// some variation
 var num = floor(numStragglers / types.length);
 for (var i = 0; i < types.length; ++i)
 {
 	group = new SimpleGroup(
 		[new SimpleObject(types[i], 1,1, 0,3)],
 		true, clForest
 	);
 	createObjectGroups(group, 0,
 		[avoidClasses(clForest, 1, clHill, 1, clPlayer, 9, clMetal, 6, clRock, 6), stayClasses(clLand, 4)],
 		num
 	);
 }
 
 var planetm = 1;
 if (random_terrain == g_BiomeTropic)
 	planetm = 8;
 
 //create small grass tufts
 log("Creating small grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)]
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clHill, 2, clPlayer, 2, clDirt, 0), stayClasses(clLand, 4)],
 	planetm * scaleByMapSize(13, 200)
 );
 
 RMS.SetProgress(90);
 
 // create large grass tufts
 log("Creating large grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aGrass, 2,4, 0,1.8, -PI/8,PI/8), new SimpleObject(aGrassShort, 3,6, 1.2,2.5, -PI/8,PI/8)]
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clHill, 2, clPlayer, 2, clDirt, 1, clForest, 0), stayClasses(clLand, 4)],
 	planetm * scaleByMapSize(13, 200)
 );
 
 RMS.SetProgress(95);
 
 // create bushes
 log("Creating bushes...");
 group = new SimpleGroup(
 	[new SimpleObject(aBushMedium, 1,2, 0,2), new SimpleObject(aBushSmall, 2,4, 0,2)]
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clHill, 1, clPlayer, 1, clDirt, 1), stayClasses(clLand, 4)],
 	planetm * scaleByMapSize(13, 200), 50
 );
 
-random_terrain = randInt(1,3);
-if (random_terrain == 1)
-	setSkySet("cirrus");
-else if (random_terrain == 2)
-	setSkySet("cumulus");
-else if (random_terrain == 3)
-	setSkySet("sunny");
-
+setSkySet(pickRandom(["cirrus", "cumulus", "sunny"]));
 setSunRotation(randFloat(0, TWO_PI));
 setSunElevation(randFloat(PI/ 5, PI / 3));
 
 // Export map data
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/unknown.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/unknown.js	(revision 19285)
+++ ps/trunk/binaries/data/mods/public/maps/random/unknown.js	(revision 19286)
@@ -1,2040 +1,2027 @@
 RMS.LoadLibrary("rmgen");
 
 TILE_CENTERED_HEIGHT_MAP = true;
 //random terrain textures
 var random_terrain = randomizeBiome();
 
 const tMainTerrain = rBiomeT1();
 const tForestFloor1 = rBiomeT2();
 const tForestFloor2 = rBiomeT3();
 const tCliff = rBiomeT4();
 const tTier1Terrain = rBiomeT5();
 const tTier2Terrain = rBiomeT6();
 const tTier3Terrain = rBiomeT7();
 const tHill = rBiomeT8();
 const tDirt = rBiomeT9();
 const tRoad = rBiomeT10();
 const tRoadWild = rBiomeT11();
 const tTier4Terrain = rBiomeT12();
 const tShoreBlend = rBiomeT13();
 const tShore = rBiomeT14();
 const tWater = rBiomeT15();
 
 // gaia entities
 const oTree1 = rBiomeE1();
 const oTree2 = rBiomeE2();
 const oTree3 = rBiomeE3();
 const oTree4 = rBiomeE4();
 const oTree5 = rBiomeE5();
 const oFruitBush = rBiomeE6();
 const oMainHuntableAnimal = rBiomeE8();
 const oFish = rBiomeE9();
 const oSecondaryHuntableAnimal = rBiomeE10();
 const oStoneLarge = rBiomeE11();
 const oStoneSmall = rBiomeE12();
 const oMetalLarge = rBiomeE13();
 const oWood = "gaia/special_treasure_wood";
 
 // decorative props
 const aGrass = rBiomeA1();
 const aGrassShort = rBiomeA2();
 const aReeds = rBiomeA3();
 const aLillies = rBiomeA4();
 const aRockLarge = rBiomeA5();
 const aRockMedium = rBiomeA6();
 const aBushMedium = rBiomeA7();
 const aBushSmall = rBiomeA8();
 
 const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
 const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
 
 log("Initializing map...");
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 const mapArea = mapSize*mapSize;
 
 // create tile classes
 
 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 clSettlement = createTileClass();
 var clLand = createTileClass();
 var clShallow = createTileClass();
 
 for (var ix = 0; ix < mapSize; ix++)
 {
 	for (var iz = 0; iz < mapSize; iz++)
 	{
 		var x = ix / (mapSize + 1.0);
 		var z = iz / (mapSize + 1.0);
 			placeTerrain(ix, iz, tWater);
 	}
 }
 
 var iberianTowers = false;
 var md = randInt(1,13);
 var needsAdditionalWood = false;
 //*****************************************************************************************************************************
 if (md == 1) //archipelago and island
 {
 	needsAdditionalWood = true;
 	iberianTowers = true;
 
 	// randomize player order
 	var playerIDs = [];
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerIDs.push(i+1);
 	}
 	playerIDs = sortPlayers(playerIDs);
 
 	// place players
 
 	var playerX = new Array(numPlayers);
 	var playerZ = new Array(numPlayers);
 	var playerAngle = new Array(numPlayers);
 
 	var startAngle = randFloat(0, TWO_PI);
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerAngle[i] = startAngle + i*TWO_PI/numPlayers;
 		playerX[i] = 0.5 + 0.35*cos(playerAngle[i]);
 		playerZ[i] = 0.5 + 0.35*sin(playerAngle[i]);
 	}
 
 	var mdd1 = randInt(1,3);
 
 	for (var i = 0; i < numPlayers; ++i)
 	{
 		var radius = scaleByMapSize(17, 29);
 		var shoreRadius = 4;
 		var elevation = 3;
 
 		var hillSize = PI * radius * radius;
 		// get the x and z in tiles
 		var fx = fractionToTiles(playerX[i]);
 		var fz = fractionToTiles(playerZ[i]);
 		var ix = round(fx);
 		var iz = round(fz);
 		// create a player island
 		var placer = new ClumpPlacer(hillSize, 0.80, 0.1, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tMainTerrain , tMainTerrain, tMainTerrain],		// terrains
 			[1, shoreRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			shoreRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clPlayer)], null);
 	}
 	if (mdd1 == 1) //archipelago
 	{
 		// create islands
 		log("Creating islands...");
 		placer = new ClumpPlacer(floor(hillSize*randFloat(0.8,1.2)), 0.80, 0.1, 10);
 		terrainPainter = new LayeredPainter(
 			[tMainTerrain, tMainTerrain],		// terrains
 			[2]								// widths
 		);
 		elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 4);
 		createAreas(
 			placer,
 			[terrainPainter, elevationPainter, paintClass(clLand)],
 			null,
 			scaleByMapSize(2, 5)*randInt(8,14)
 		);
 
 		// create shore jaggedness
 		log("Creating shore jaggedness...");
 		placer = new ClumpPlacer(scaleByMapSize(15, 80), 0.2, 0.1, 1);
 		terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[2]								// widths
 		);
 		elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 4);
 		createAreas(
 			placer,
 			[terrainPainter, elevationPainter, paintClass(clLand)],
 			borderClasses(clLand, 6, 3),
 			scaleByMapSize(12, 130) * 2, 150
 		);
 	}
 	else if (mdd1 == 2) //islands
 	{
 		// create islands
 		log("Creating islands...");
 		placer = new ClumpPlacer(floor(hillSize*randFloat(0.6,1.4)), 0.80, 0.1, randFloat(0.0, 0.2));
 		terrainPainter = new LayeredPainter(
 			[tMainTerrain, tMainTerrain],		// terrains
 			[2]								// widths
 		);
 		elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 4);
 		createAreas(
 			placer,
 			[terrainPainter, elevationPainter, paintClass(clLand)],
 			avoidClasses(clLand, 3, clPlayer, 3),
 			scaleByMapSize(6, 10)*randInt(8,14)
 		);
 
 		// create small islands
 		log("Creating small islands...");
 		placer = new ClumpPlacer(floor(hillSize*randFloat(0.3,0.7)), 0.80, 0.1, 0.07);
 		terrainPainter = new LayeredPainter(
 			[tMainTerrain, tMainTerrain],		// terrains
 			[2]								// widths
 		);
 		elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 6);
 		createAreas(
 			placer,
 			[terrainPainter, elevationPainter, paintClass(clLand)],
 			avoidClasses(clLand, 3, clPlayer, 3),
 			scaleByMapSize(2, 6)*randInt(6,15), 25
 		);
 	}
 	else if (mdd1 == 3) // tight islands
 	{
 		// create islands
 		log("Creating islands...");
 		placer = new ClumpPlacer(floor(hillSize*randFloat(0.8,1.2)), 0.80, 0.1, 10);
 		terrainPainter = new LayeredPainter(
 			[tMainTerrain, tMainTerrain],		// terrains
 			[2]								// widths
 		);
 		elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 4);
 		createAreas(
 			placer,
 			[terrainPainter, elevationPainter, paintClass(clLand)],
 			avoidClasses(clLand, randInt(8, 16), clPlayer, 3),
 			scaleByMapSize(2, 5)*randInt(8,14)
 		);
 	}
 
 }
 //********************************************************************************************************
 else if (md == 2) //continent
 {
 
 	// randomize player order
 	var playerIDs = [];
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerIDs.push(i+1);
 	}
 	playerIDs = sortPlayers(playerIDs);
 
 	// place players
 
 	var playerX = new Array(numPlayers);
 	var playerZ = new Array(numPlayers);
 	var playerAngle = new Array(numPlayers);
 
 	var startAngle = randFloat(0, TWO_PI);
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerAngle[i] = startAngle + i*TWO_PI/numPlayers;
 		playerX[i] = 0.5 + 0.25*cos(playerAngle[i]);
 		playerZ[i] = 0.5 + 0.25*sin(playerAngle[i]);
 
 		var fx = fractionToTiles(playerX[i]);
 		var fz = fractionToTiles(playerZ[i]);
 		var ix = round(fx);
 		var iz = round(fz);
 		addToClass(ix, iz, clPlayer);
 		addToClass(ix+5, iz, clPlayer);
 		addToClass(ix, iz+5, clPlayer);
 		addToClass(ix-5, iz, clPlayer);
 		addToClass(ix, iz-5, clPlayer);
 	}
 
 	var fx = fractionToTiles(0.5);
 	var fz = fractionToTiles(0.5);
 	ix = round(fx);
 	iz = round(fz);
 
 	var placer = new ClumpPlacer(mapArea * 0.45, 0.9, 0.09, 10, ix, iz);
 	var terrainPainter = new LayeredPainter(
 		[tWater, tShore, tMainTerrain],		// terrains
 		[4, 2]		// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		3,				// elevation
 		4				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 	var clPeninsulaSteam = createTileClass();
 
 	if (randInt(1,3)==1) // peninsula
 	{
 		var angle = randFloat(0, TWO_PI);
 
 		var fx = fractionToTiles(0.5 + 0.25*cos(angle));
 		var fz = fractionToTiles(0.5 + 0.25*sin(angle));
 		ix = round(fx);
 		iz = round(fz);
 
 		var placer = new ClumpPlacer(mapArea * 0.45, 0.9, 0.09, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tWater, tShore, tMainTerrain],		// terrains
 			[4, 2]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			3,				// elevation
 			4				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 		var fx = fractionToTiles(0.5 + 0.35*cos(angle));
 		var fz = fractionToTiles(0.5 + 0.35*sin(angle));
 		ix = round(fx);
 		iz = round(fz);
 
 		var placer = new ClumpPlacer(mapArea * 0.3, 0.9, 0.01, 10, ix, iz);
 		createArea(placer, [paintClass(clPeninsulaSteam)], null);
 	}
 
 	// create shore jaggedness
 	log("Creating shore jaggedness...");
 	placer = new ClumpPlacer(scaleByMapSize(20, 150), 0.2, 0.1, 1);
 	terrainPainter = new LayeredPainter(
 		[tCliff, tHill],		// terrains
 		[2]								// widths
 	);
 	elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -5, 4);
 	createAreas(
 		placer,
 		[terrainPainter, elevationPainter, unPaintClass(clLand)],
 		[avoidClasses(clPlayer, 20, clPeninsulaSteam, 20), borderClasses(clLand, 7, 7)],
 		scaleByMapSize(7, 130) * 2, 150
 	);
 
 	// create outward shore jaggedness
 	log("Creating shore jaggedness...");
 	placer = new ClumpPlacer(scaleByMapSize(20, 150), 0.2, 0.1, 1);
 	terrainPainter = new LayeredPainter(
 		[tCliff, tHill],		// terrains
 		[2]								// widths
 	);
 	elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 4);
 	createAreas(
 		placer,
 		[terrainPainter, elevationPainter, paintClass(clLand)],
 		[avoidClasses(clPlayer, 20), borderClasses(clLand, 7, 7)],
 		scaleByMapSize(7, 130) * 2, 150
 	);
 }
 //********************************************************************************************************
 else if (md == 3) //central sea
 {
 // randomize player order
 var playerIDs = [];
 for (var i = 0; i < numPlayers; i++)
 {
 	playerIDs.push(i+1);
 }
 playerIDs = primeSortPlayers(sortPlayers(playerIDs));
 
 	// place players
 
 	var playerX = new Array(numPlayers);
 	var playerZ = new Array(numPlayers);
 	var playerAngle = new Array(numPlayers);
 	var playerPos = new Array(numPlayers);
 	var iop = 0;
 
 	var mdd1 = randInt(1,2);
 	if (mdd1 == 1) //vertical
 	{
 		for (var i = 0; i < numPlayers; i++)
 		{
 			iop = i - 1;
 			if (!(numPlayers%2)){
 				playerPos[i] = ((iop + abs(iop%2))/2 + 1) / ((numPlayers / 2) + 1);
 			}
 			else
 			{
 				if (iop%2)
 				{
 					playerPos[i] = ((iop + abs(iop%2))/2 + 1) / (((numPlayers + 1) / 2) + 1);
 				}
 				else
 				{
 					playerPos[i] = ((iop)/2 + 1) / ((((numPlayers - 1)) / 2) + 1);
 				}
 			}
 			playerZ[i] = playerPos[i];
 			playerX[i] = 0.2 + 0.6*(i%2);
 		}
 	}
 	else //horizontal
 	{
 		for (var i = 0; i < numPlayers; i++)
 		{
 			iop = i - 1;
 			if (!(numPlayers%2)){
 				playerPos[i] = ((iop + abs(iop%2))/2 + 1) / ((numPlayers / 2) + 1);
 			}
 			else
 			{
 				if (iop%2)
 				{
 					playerPos[i] = ((iop + abs(iop%2))/2 + 1) / (((numPlayers + 1) / 2) + 1);
 				}
 				else
 				{
 					playerPos[i] = ((iop)/2 + 1) / ((((numPlayers - 1)) / 2) + 1);
 				}
 			}
 			playerZ[i] = 0.2 + 0.6*(i%2);
 			playerX[i] = playerPos[i];
 		}
 	}
 
 
 	var WATER_WIDTH = randFloat(0.22,0.3)+scaleByMapSize(1,4)/20;
 	log("Creating sea");
 	var theta = randFloat(0, 1);
 	var theta2 = randFloat(0, 1);
 	var seed = randFloat(2,3);
 	var seed2 = randFloat(2,3);
 	for (var ix = 0; ix < mapSize; ix++)
 	{
 		for (var iz = 0; iz < mapSize; iz++)
 		{
 			var x = ix / (mapSize + 1.0);
 			var z = iz / (mapSize + 1.0);
 
 			// add the rough shape of the water
 			var km = 20/scaleByMapSize(35, 160);
 
 			var fadeDist = 0.05;
 
 			if (mdd1 == 1) //vertical
 			{
 				var cu = km*rndRiver(theta+z*0.5*(mapSize/64),seed);
 				var cu2 = km*rndRiver(theta2+z*0.5*(mapSize/64),seed2);
 
 				if ((x > cu + 0.5 - WATER_WIDTH/2) && (x < cu2 + 0.5 + WATER_WIDTH/2))
 				{
 					var h;
 					if (x < (cu + 0.5 + fadeDist - WATER_WIDTH/2))
 					{
 						h = 3 - 6 * (1 - ((cu + 0.5 + fadeDist - WATER_WIDTH/2) - x)/fadeDist);
 					}
 					else if (x > (cu2 + 0.5 - fadeDist + WATER_WIDTH/2))
 					{
 						h = 3 - 6 * (1 - (x - (cu2 + 0.5 - fadeDist + WATER_WIDTH/2))/fadeDist);
 					}
 					else
 					{
 						h = -3.0;
 					}
 
 					if (h < -1.5)
 					{
 						placeTerrain(ix, iz, tWater);
 					}
 					else
 					{
 						placeTerrain(ix, iz, tShore);
 					}
 
 					setHeight(ix, iz, h);
 					if (h < 0){
 						addToClass(ix, iz, clWater);
 					}
 				}
 				else
 				{
 					setHeight(ix, iz, 3.1);
 					addToClass(ix, iz, clLand);
 				}
 			}
 			else //horizontal
 			{
 				var cu = km*rndRiver(theta+x*0.5*(mapSize/64),seed);
 				var cu2 = km*rndRiver(theta2+x*0.5*(mapSize/64),seed2);
 
 				if ((z > cu + 0.5 - WATER_WIDTH/2) && (z < cu2 + 0.5 + WATER_WIDTH/2))
 				{
 					var h;
 					if (z < (cu + 0.5 + fadeDist - WATER_WIDTH/2))
 					{
 						h = 3 - 6 * (1 - ((cu + 0.5 + fadeDist - WATER_WIDTH/2) - z)/fadeDist);
 					}
 					else if (z > (cu2 + 0.5 - fadeDist + WATER_WIDTH/2))
 					{
 						h = 3 - 6 * (1 - (z - (cu2 + 0.5 - fadeDist + WATER_WIDTH/2))/fadeDist);
 					}
 					else
 					{
 						h = -3.0;
 					}
 
 					if (h < -1.5)
 					{
 						placeTerrain(ix, iz, tWater);
 					}
 					else
 					{
 						placeTerrain(ix, iz, tShore);
 					}
 
 					setHeight(ix, iz, h);
 					if (h < 0){
 						addToClass(ix, iz, clWater);
 					}
 				}
 				else
 				{
 					setHeight(ix, iz, 3.1);
 					addToClass(ix, iz, clLand);
 				}
 			}
 		}
 	}
 
 	if (!randInt(3))
 	{
 		// linked
 		if (mdd1 == 1) //vertical
 		{
 			var placer = new PathPlacer(1, fractionToTiles(0.5), fractionToTiles(0.99), fractionToTiles(0.5), scaleByMapSize(randInt(16,24),randInt(100,140)), 0.5, 3*(scaleByMapSize(1,4)), 0.1, 0.01);
 		}
 		else
 		{
 			var placer = new PathPlacer(fractionToTiles(0.5), 1, fractionToTiles(0.5), fractionToTiles(0.99), scaleByMapSize(randInt(16,24),randInt(100,140)), 0.5, 3*(scaleByMapSize(1,4)), 0.1, 0.01);
 		}
 		var terrainPainter = new LayeredPainter(
 			[tMainTerrain, tMainTerrain, tMainTerrain],		// terrains
 			[1, 3]								// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			3.1,				// elevation
 			4				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, unPaintClass(clWater)], null);
 	}
 	var mdd2 = randInt(1,7);
 	if (mdd2 == 1)
 	{
 		// create islands
 		log("Creating islands...");
 		placer = new ClumpPlacer(randInt(scaleByMapSize(8,15),scaleByMapSize(15,23))*randInt(scaleByMapSize(8,15),scaleByMapSize(15,23)), 0.80, 0.1, randFloat(0.0, 0.2));
 		terrainPainter = new LayeredPainter(
 			[tMainTerrain, tMainTerrain],		// terrains
 			[2]								// widths
 		);
 		elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3.1, 4);
 		createAreas(
 			placer,
 			[terrainPainter, elevationPainter, paintClass(clLand)],
 			avoidClasses(clLand, 3, clPlayer, 3),
 			scaleByMapSize(2, 5)*randInt(8,14)
 		);
 	}
 	else if (mdd2 == 2)
 	{
 		// create extentions
 		log("Creating extentions...");
 		placer = new ClumpPlacer(randInt(scaleByMapSize(13,24),scaleByMapSize(24,45))*randInt(scaleByMapSize(13,24),scaleByMapSize(24,45)), 0.80, 0.1, 10);
 		terrainPainter = new LayeredPainter(
 			[tMainTerrain, tMainTerrain],		// terrains
 			[2]								// widths
 		);
 		elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3.1, 4);
 		createAreas(
 			placer,
 			[terrainPainter, elevationPainter, paintClass(clLand)],
 			null,
 			scaleByMapSize(2, 5)*randInt(8,14)
 		);
 	}
 }
 //********************************************************************************************************
 else if (md == 4) //central river
 {
 
 	for (var ix = 0; ix < mapSize; ix++)
 	{
 		for (var iz = 0; iz < mapSize; iz++)
 		{
 			var x = ix / (mapSize + 1.0);
 			var z = iz / (mapSize + 1.0);
 				setHeight(ix, iz, 3);
 		}
 	}
 
 	// randomize player order
 	var playerIDs = [];
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerIDs.push(i+1);
 	}
 	playerIDs = primeSortPlayers(sortPlayers(playerIDs));
 
 	// place players
 
 	var playerX = new Array(numPlayers);
 	var playerZ = new Array(numPlayers);
 	var playerAngle = new Array(numPlayers);
 	var playerPos = new Array(numPlayers);
 	var iop = 0;
 	var mdd1 = randInt(1,2);
 	if (mdd1 == 1) //horizontal
 	{
 		for (var i = 0; i < numPlayers; i++)
 		{
 			iop = i - 1;
 			if (!(numPlayers%2)){
 				playerPos[i] = ((iop + abs(iop%2))/2 + 1) / ((numPlayers / 2) + 1);
 			}
 			else
 			{
 				if (iop%2)
 				{
 					playerPos[i] = ((iop + abs(iop%2))/2 + 1) / (((numPlayers + 1) / 2) + 1);
 				}
 				else
 				{
 					playerPos[i] = ((iop)/2 + 1) / ((((numPlayers - 1)) / 2) + 1);
 				}
 			}
 
 			playerZ[i] = 0.25 + 0.5*(i%2);
 			playerX[i] = playerPos[i];
 		}
 	}
 	else //vertical
 	{
 		for (var i = 0; i < numPlayers; i++)
 		{
 			iop = i - 1;
 			if (!(numPlayers%2)){
 				playerPos[i] = ((iop + abs(iop%2))/2 + 1) / ((numPlayers / 2) + 1);
 			}
 			else
 			{
 				if (iop%2)
 				{
 					playerPos[i] = ((iop + abs(iop%2))/2 + 1) / (((numPlayers + 1) / 2) + 1);
 				}
 				else
 				{
 					playerPos[i] = ((iop)/2 + 1) / ((((numPlayers - 1)) / 2) + 1);
 				}
 			}
 
 			playerZ[i] = playerPos[i];
 			playerX[i] = 0.25 + 0.5*(i%2);
 		}
 	}
 
 	// create the main river
 	log("Creating the main river");
 
 	if (mdd1 == 2)
 		var placer = new PathPlacer(fractionToTiles(0.5), 1, fractionToTiles(0.5) , fractionToTiles(0.99), scaleByMapSize(14,24), 0.5, 3*(scaleByMapSize(1,4)), 0.1, 0.01);
 	else
 		var placer = new PathPlacer(1, fractionToTiles(0.5), fractionToTiles(0.99), fractionToTiles(0.5), scaleByMapSize(14,24), 0.5, 3*(scaleByMapSize(1,4)), 0.1, 0.01);
 
 	var terrainPainter = new LayeredPainter(
 		[tShore, tWater, tWater],		// terrains
 		[1, 3]								// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		-4,				// elevation
 		4				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter], avoidClasses(clPlayer, 4));
 
 	if (mdd1 == 1)
 		placer = new ClumpPlacer(floor(PI*scaleByMapSize(10,20)*scaleByMapSize(10,20)/4), 0.95, 0.6, 10, 1, fractionToTiles(0.5));
 	else
 		placer = new ClumpPlacer(floor(PI*scaleByMapSize(10,20)*scaleByMapSize(10,20)/4), 0.95, 0.6, 10, fractionToTiles(0.5), 1);
 
 	var painter = new LayeredPainter([tWater, tWater], [1]);
 	var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -4, 2);
 	createArea(placer, [painter, elevationPainter], avoidClasses(clPlayer, 8));
 
 	if (mdd1 == 1)
 		placer = new ClumpPlacer(floor(PI*scaleByMapSize(10,20)*scaleByMapSize(10,20)/4), 0.95, 0.6, 10, fractionToTiles(0.99), fractionToTiles(0.5));
 	else
 		placer = new ClumpPlacer(floor(PI*scaleByMapSize(10,20)*scaleByMapSize(10,20)/4), 0.95, 0.6, 10, fractionToTiles(0.5), fractionToTiles(0.99));
 
 	var painter = new LayeredPainter([tWater, tWater], [1]);
 	var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -4, 2);
 	createArea(placer, [painter, elevationPainter], avoidClasses(clPlayer, 8));
 
 	var mdd2 = randInt(1,2);
 	if (mdd2 == 1)
 	{
 		// create the shallows of the main river
 		log("Creating the shallows of the main river");
 
 		for (var i = 0; i <= randInt(1, scaleByMapSize(4,8)); i++)
 		{
 			var cLocation = randFloat(0.15,0.85);
 			if (mdd1 == 1)
 				passageMaker(floor(fractionToTiles(cLocation)), floor(fractionToTiles(0.35)), floor(fractionToTiles(cLocation)), floor(fractionToTiles(0.65)), scaleByMapSize(4,8), -2, -2, 2, clShallow, undefined, -4);
 			else
 				passageMaker(floor(fractionToTiles(0.35)), floor(fractionToTiles(cLocation)), floor(fractionToTiles(0.65)), floor(fractionToTiles(cLocation)), scaleByMapSize(4,8), -2, -2, 2, clShallow, undefined, -4);
 		}
 	}
 
 	if (randInt(1,2) == 1)
 	{
 		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 = scaleByMapSize(17,29)/3;
 			placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 			createArea(placer, paintClass(clPlayer), null);
 		}
 
 		// create tributaries
 		log("Creating tributaries");
 
 		for (var i = 0; i <= randInt(8, (scaleByMapSize(12,20))); i++)
 		{
 			var cLocation = randFloat(0.05,0.95);
 			var tang = randFloat(PI*0.2, PI*0.8)*((randInt(2)-0.5)*2);
 			if (tang > 0)
 			{
 				var cDistance = 0.05;
 			}
 			else
 			{
 				var cDistance = -0.05;
 			}
 			if (mdd1 == 1)
 				var point = getTIPIADBON([fractionToTiles(cLocation), fractionToTiles(0.5 + cDistance)], [fractionToTiles(cLocation), fractionToTiles(0.5 - cDistance)], [-6, -1.5], 0.5, 5, 0.01);
 			else
 				var point = getTIPIADBON([fractionToTiles(0.5 + cDistance), fractionToTiles(cLocation)], [fractionToTiles(0.5 - cDistance), fractionToTiles(cLocation)], [-6, -1.5], 0.5, 5, 0.01);
 
 			if (point !== undefined)
 			{
 				if (mdd1 == 1)
 					var placer = new PathPlacer(floor(point[0]), floor(point[1]), floor(fractionToTiles(0.5 + 0.49*cos(tang))), floor(fractionToTiles(0.5 + 0.49*sin(tang))), scaleByMapSize(10,20), 0.4, 3*(scaleByMapSize(1,4)), 0.1, 0.05);
 				else
 					var placer = new PathPlacer(floor(point[0]), floor(point[1]), floor(fractionToTiles(0.5 + 0.49*sin(tang))), floor(fractionToTiles(0.5 + 0.49*cos(tang))), scaleByMapSize(10,20), 0.4, 3*(scaleByMapSize(1,4)), 0.1, 0.05);
 
 
 				var terrainPainter = new LayeredPainter(
 					[tShore, tWater, tWater],		// terrains
 					[1, 3]								// widths
 				);
 				var elevationPainter = new SmoothElevationPainter(
 					ELEVATION_SET,			// type
 					-4,				// elevation
 					4				// blend radius
 				);
 				var success = createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 3, clWater, 3, clShallow, 2));
 				if (success !== undefined)
 				{
 					if (mdd1 == 1)
 						placer = new ClumpPlacer(floor(PI*scaleByMapSize(10,20)*scaleByMapSize(10,20)/4), 0.95, 0.6, 10, fractionToTiles(0.5 + 0.49*cos(tang)), fractionToTiles(0.5 + 0.49*sin(tang)));
 					else
 						placer = new ClumpPlacer(floor(PI*scaleByMapSize(10,20)*scaleByMapSize(10,20)/4), 0.95, 0.6, 10, fractionToTiles(0.5 + 0.49*sin(tang)), fractionToTiles(0.5 + 0.49*cos(tang)));
 
 					var painter = new LayeredPainter([tWater, tWater], [1]);
 					var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -4, 2);
 					createArea(placer, [painter, elevationPainter], avoidClasses(clPlayer, 3));
 				}
 			}
 		}
 	}
 }
 //********************************************************************************************************
 else if (md == 5) //rivers and lake
 {
 
 	// randomize player order
 	var playerIDs = [];
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerIDs.push(i+1);
 	}
 	playerIDs = sortPlayers(playerIDs);
 
 	// place players
 
 	var playerX = new Array(numPlayers);
 	var playerZ = new Array(numPlayers);
 	var playerAngle = new Array(numPlayers);
 
 	var startAngle = randFloat(0, TWO_PI);
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerAngle[i] = startAngle + i*TWO_PI/numPlayers;
 		playerX[i] = 0.5 + 0.35*cos(playerAngle[i]);
 		playerZ[i] = 0.5 + 0.35*sin(playerAngle[i]);
 
 		var fx = fractionToTiles(playerX[i]);
 		var fz = fractionToTiles(playerZ[i]);
 		var ix = round(fx);
 		var iz = round(fz);
 		addToClass(ix, iz, clPlayer);
 		addToClass(ix+5, iz, clPlayer);
 		addToClass(ix, iz+5, clPlayer);
 		addToClass(ix-5, iz, clPlayer);
 		addToClass(ix, iz-5, clPlayer);
 	}
 
 
 
 	for (var ix = 0; ix < mapSize; ix++)
 	{
 		for (var iz = 0; iz < mapSize; iz++)
 		{
 			var x = ix / (mapSize + 1.0);
 			var z = iz / (mapSize + 1.0);
 				setHeight(ix, iz, 3);
 		}
 	}
 	var mdd1 = randInt(1,2);
 	if (mdd1 == 1) //lake
 	{
 		var fx = fractionToTiles(0.5);
 		var fz = fractionToTiles(0.5);
 		ix = round(fx);
 		iz = round(fz);
 
 		var lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 6))));
 
 		var placer = new ClumpPlacer(mapArea * 0.09 * lSize, 0.7, 0.1, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tShore, tWater, tWater, tWater],		// terrains
 			[1, 4, 2]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			-4,				// elevation
 			4				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], null);
 
 		// create shore jaggedness
 		log("Creating shore jaggedness...");
 		placer = new ClumpPlacer(scaleByMapSize(20, 150), 0.2, 0.1, 1);
 		terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[2]								// widths
 		);
 		elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -5, 4);
 		createAreas(
 			placer,
 			[terrainPainter, elevationPainter, paintClass(clWater)],
 			[avoidClasses(clPlayer, 20), borderClasses(clWater, 6, 4)],
 			scaleByMapSize(7, 130) * 2, 150
 		);
 
 		placer = new ClumpPlacer(scaleByMapSize(15, 80), 0.2, 0.1, 1);
 		terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[2]								// widths
 		);
 		elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 4);
 		createAreas(
 			placer,
 			[terrainPainter, elevationPainter, unPaintClass(clWater)],
 			borderClasses(clWater, 4, 7),
 			scaleByMapSize(12, 130) * 2, 150
 		);
 	}
 
 	if (randInt(1,2) == 1) //rivers
 	{
 		//create rivers
 		log ("Creating rivers...");
 		for (var m = 0; m < numPlayers; m++)
 		{
 			var tang = startAngle + (m+0.5)*TWO_PI/(numPlayers);
 			var placer = new PathPlacer(fractionToTiles(0.5), fractionToTiles(0.5), fractionToTiles(0.5 + 0.49*cos(tang)), fractionToTiles(0.5 + 0.49*sin(tang)), scaleByMapSize(14,24), 0.4, 3*(scaleByMapSize(1,3)), 0.2, 0.05);
 			var terrainPainter = new LayeredPainter(
 				[tShore, tWater, tWater],		// terrains
 				[1, 3]								// widths
 			);
 			var elevationPainter = new SmoothElevationPainter(
 				ELEVATION_SET,			// type
 				-4,				// elevation
 				4				// blend radius
 			);
 			createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 5));
 			placer = new ClumpPlacer(floor(PI*scaleByMapSize(10,50)*scaleByMapSize(10,50)/5), 0.95, 0.6, 10, fractionToTiles(0.5 + 0.49*cos(tang)), fractionToTiles(0.5 + 0.49*sin(tang)));
 			var painter = new LayeredPainter([tWater, tWater], [1]);
 			var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -4, 0);
 			createArea(placer, [painter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 5));
 
 		}
 
 		var fx = fractionToTiles(0.5);
 		var fz = fractionToTiles(0.5);
 		ix = round(fx);
 		iz = round(fz);
 
 		var placer = new ClumpPlacer(mapArea * 0.005, 0.7, 0.1, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tShore, tWater, tWater, tWater],		// terrains
 			[1, 4, 2]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			-4,				// elevation
 			4				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], null);
 	}
 
 	if ((randInt(1,3) == 1)&&(mdd1 == 1))//island
 	{
 		var placer = new ClumpPlacer(mapArea * 0.006 * lSize, 0.7, 0.1, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tShore, tWater, tWater, tWater],		// terrains
 			[1, 4, 2]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			3,				// elevation
 			4				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], null);
 	}
 }
 //********************************************************************************************************
 else if (md == 6) //edge seas
 {
 
 	for (var ix = 0; ix < mapSize; ix++)
 	{
 		for (var iz = 0; iz < mapSize; iz++)
 		{
 			var x = ix / (mapSize + 1.0);
 			var z = iz / (mapSize + 1.0);
 				setHeight(ix, iz, 3);
 		}
 	}
 
 	var mdd1 = randInt(1,2);
 
 	// randomize player order
 	var playerIDs = [];
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerIDs.push(i+1);
 	}
 	playerIDs = sortPlayers(playerIDs);
 
 	// place players
 
 	var playerX = new Array(numPlayers);
 	var playerZ = new Array(numPlayers);
 	var playerPos = new Array(numPlayers);
 
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerPos[i] = (i + 1) / (numPlayers + 1);
 		if (mdd1 == 1) //horizontal
 		{
 			playerX[i] = playerPos[i];
 			playerZ[i] = 0.4 + 0.2*(i%2);
 		}
 		else //vertical
 		{
 			playerX[i] = 0.4 + 0.2*(i%2);
 			playerZ[i] = playerPos[i];
 		}
 
 		var fx = fractionToTiles(playerX[i]);
 		var fz = fractionToTiles(playerZ[i]);
 		var ix = round(fx);
 		var iz = round(fz);
 		addToClass(ix, iz, clPlayer);
 		addToClass(ix+5, iz, clPlayer);
 		addToClass(ix, iz+5, clPlayer);
 		addToClass(ix-5, iz, clPlayer);
 		addToClass(ix, iz-5, clPlayer);
 	}
 
 	var mdd2 = randInt(1,3);
 	var fadedistance = 7;
 
 	if (mdd1 == 1)
 	{
 		if ((mdd2 == 1)||(mdd2 == 3))
 		{
 			var distance = randFloat(0., 0.1);
 			for (var ix = 0; ix < mapSize; ix++)
 			{
 				for (var iz = 0; iz < mapSize; iz++)
 				{
 					if (iz > (0.69+distance) * mapSize)
 					{
 						if (iz < (0.69+distance) * mapSize + fadedistance)
 						{
 							setHeight(ix, iz, 3 - 7 * (iz - (0.69+distance) * mapSize) / fadedistance);
 							if (3 - 7 * (iz - (0.69+distance) * mapSize) / fadedistance < 0.5)
 								addToClass(ix, iz, clWater);
 						}
 						else
 						{
 							setHeight(ix, iz, -4);
 							addToClass(ix, iz, clWater);
 						}
 					}
 				}
 
 			}
 
 			for (var i = 0; i < scaleByMapSize(20,120); i++)
 			{
 				placer = new ClumpPlacer(scaleByMapSize(50, 70), 0.2, 0.1, 10, randFloat(0.1,0.9)*mapSize, randFloat(0.67+distance,0.74+distance)*mapSize);
 				var terrainPainter = new LayeredPainter(
 					[tMainTerrain, tMainTerrain],		// terrains
 					[2]								// widths
 				);
 				var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 3);
 				createArea(
 					placer,
 					[terrainPainter, elevationPainter, unPaintClass(clWater)],
 					null
 				);
 			}
 		}
 		if ((mdd2 == 2)||(mdd2 == 3))
 		{
 			var distance = randFloat(0., 0.1);
 			for (var ix = 0; ix < mapSize; ix++)
 			{
 				for (var iz = 0; iz < mapSize; iz++)
 				{
 					if (iz < (0.31-distance) * mapSize)
 					{
 						if (iz > (0.31-distance) * mapSize - fadedistance)
 						{
 							setHeight(ix, iz, 3 - 7 * ((0.31-distance) * mapSize - iz) / fadedistance);
 							if (3 - 7 * ((0.31-distance) * mapSize - iz) / fadedistance < 0.5)
 								addToClass(ix, iz, clWater);
 						}
 						else
 						{
 							setHeight(ix, iz, -4);
 							addToClass(ix, iz, clWater);
 						}
 					}
 				}
 			}
 
 			for (var i = 0; i < scaleByMapSize(20,120); i++)
 			{
 				placer = new ClumpPlacer(scaleByMapSize(50, 70), 0.2, 0.1, 10, randFloat(0.1,0.9)*mapSize, randFloat(0.26-distance,0.34-distance)*mapSize);
 				var terrainPainter = new LayeredPainter(
 					[tMainTerrain, tMainTerrain],		// terrains
 					[2]								// widths
 				);
 				var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 3);
 				createArea(
 					placer,
 					[terrainPainter, elevationPainter, unPaintClass(clWater)],
 					null
 				);
 			}
 		}
 	}
 	else //vertical
 	{
 		if ((mdd2 == 1)||(mdd2 == 3))
 		{
 			var distance = randFloat(0., 0.1);
 			for (var ix = 0; ix < mapSize; ix++)
 			{
 				for (var iz = 0; iz < mapSize; iz++)
 				{
 					if (ix > (0.69+distance) * mapSize)
 					{
 						if (ix < (0.69+distance) * mapSize + fadedistance)
 						{
 							setHeight(ix, iz, 3 - 7 * (ix - (0.69+distance) * mapSize) / fadedistance);
 							if (3 - 7 * (ix - (0.69+distance) * mapSize) / fadedistance < 0.5)
 								addToClass(ix, iz, clWater);
 						}
 						else
 						{
 							setHeight(ix, iz, -4);
 							addToClass(ix, iz, clWater);
 						}
 					}
 				}
 			}
 		}
 		if ((mdd2 == 2)||(mdd2 == 3))
 		{
 			var distance = randFloat(0., 0.1);
 			for (var ix = 0; ix < mapSize; ix++)
 			{
 				for (var iz = 0; iz < mapSize; iz++)
 				{
 					if (ix < (0.31-distance) * mapSize)
 					{
 						if (ix > (0.31-distance) * mapSize - fadedistance)
 						{
 							setHeight(ix, iz, 3 - 7 * ((0.31-distance) * mapSize - ix) / fadedistance);
 							if (3 - 7 * ((0.31-distance) * mapSize - ix) / fadedistance < 0.5)
 								addToClass(ix, iz, clWater);
 						}
 						else
 						{
 							setHeight(ix, iz, -4);
 							addToClass(ix, iz, clWater);
 						}
 					}
 				}
 			}
 		}
 	}
 
 	// create shore jaggedness
 	log("Creating shore jaggedness...");
 	placer = new ClumpPlacer(scaleByMapSize(20, 150), 0.2, 0.1, 1);
 	terrainPainter = new LayeredPainter(
 		[tCliff, tHill],		// terrains
 		[2]								// widths
 	);
 	elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -5, 4);
 	createAreas(
 		placer,
 		[terrainPainter, elevationPainter, paintClass(clWater)],
 		[avoidClasses(clPlayer, 20), borderClasses(clWater, 6, 4)],
 		scaleByMapSize(7, 130) * 2, 150
 	);
 
 	placer = new ClumpPlacer(scaleByMapSize(15, 80), 0.2, 0.1, 1);
 	terrainPainter = new LayeredPainter(
 		[tCliff, tHill],		// terrains
 		[2]								// widths
 	);
 	elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 4);
 	createAreas(
 		placer,
 		[terrainPainter, elevationPainter, unPaintClass(clWater)],
 		borderClasses(clWater, 4, 7),
 		scaleByMapSize(12, 130) * 2, 150
 	);
 
 	var mdd3 = randInt(1,3);
 	if (mdd3 == 1)
 	{
 		// create islands
 		log("Creating islands...");
 		placer = new ClumpPlacer(randInt(scaleByMapSize(8,15),scaleByMapSize(15,23))*randInt(scaleByMapSize(8,15),scaleByMapSize(15,23)), 0.80, 0.1, randFloat(0.0, 0.2));
 		terrainPainter = new LayeredPainter(
 			[tMainTerrain, tMainTerrain],		// terrains
 			[2]								// widths
 		);
 		elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3.1, 4);
 		createAreas(
 			placer,
 			[terrainPainter, elevationPainter, paintClass(clLand)],
 			avoidClasses(clLand, 3, clPlayer, 3),
 			scaleByMapSize(2, 5)*randInt(8,14)
 		);
 	}
 	else if (mdd3 == 2)
 	{
 		// create extentions
 		log("Creating extentions...");
 		placer = new ClumpPlacer(randInt(scaleByMapSize(13,24),scaleByMapSize(24,45))*randInt(scaleByMapSize(13,24),scaleByMapSize(24,45)), 0.80, 0.1, 10);
 		terrainPainter = new LayeredPainter(
 			[tMainTerrain, tMainTerrain],		// terrains
 			[2]								// widths
 		);
 		elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3.1, 4);
 		createAreas(
 			placer,
 			[terrainPainter, elevationPainter, paintClass(clLand)],
 			null,
 			scaleByMapSize(2, 5)*randInt(8,14)
 		);
 	}
 }
 //********************************************************************************************************
 else if (md == 7) //gulf
 {
 
 	for (var ix = 0; ix < mapSize; ix++)
 	{
 		for (var iz = 0; iz < mapSize; iz++)
 		{
 			var x = ix / (mapSize + 1.0);
 			var z = iz / (mapSize + 1.0);
 				setHeight(ix, iz, 3);
 		}
 	}
 
 	var mdd1 = randFloat(0,4);
 
 	// randomize player order
 	var playerIDs = [];
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerIDs.push(i+1);
 	}
 	playerIDs = sortPlayers(playerIDs);
 
 	// place players
 
 	var playerX = new Array(numPlayers);
 	var playerZ = new Array(numPlayers);
 	var playerAngle = new Array(numPlayers);
 
 	var startAngle = -PI/6 + (mdd1-1)*PI/2;
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerAngle[i] = startAngle + i*TWO_PI/(numPlayers-1)*2/3;
 		playerX[i] = 0.5 + 0.35*cos(playerAngle[i]);
 		playerZ[i] = 0.5 + 0.35*sin(playerAngle[i]);
 	}
 
 	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 = scaleByMapSize(17,29)/3;
 		placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 		createArea(placer, paintClass(clPlayer), null);
 	}
 
 	fx = fractionToTiles(0.5);
 	fz = fractionToTiles(0.5);
 	ix = round(fx);
 	iz = round(fz);
 
 	var lSize = 1;
 
 	var placer = new ClumpPlacer(mapArea * 0.08 * lSize, 0.7, 0.05, 10, ix, iz);
 	var terrainPainter = new LayeredPainter(
 		[tMainTerrain, tMainTerrain, tMainTerrain, tMainTerrain],		// terrains
 		[1, 4, 2]		// widths
 	);
 
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		-3,				// elevation
 		4				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer,floor(scaleByMapSize(15,25))));
 
 	fx = fractionToTiles(0.5 - 0.2*cos(mdd1*PI/2));
 	fz = fractionToTiles(0.5 - 0.2*sin(mdd1*PI/2));
 	ix = round(fx);
 	iz = round(fz);
 
 	var lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 6))));
 
 	var placer = new ClumpPlacer(mapArea * 0.13 * lSize, 0.7, 0.05, 10, ix, iz);
 	var terrainPainter = new LayeredPainter(
 		[tMainTerrain, tMainTerrain, tMainTerrain, tMainTerrain],		// terrains
 		[1, 4, 2]		// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		-3,				// elevation
 		4				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer,floor(scaleByMapSize(15,25))));
 
 	fx = fractionToTiles(0.5 - 0.49*cos(mdd1*PI/2));
 	fz = fractionToTiles(0.5 - 0.49*sin(mdd1*PI/2));
 	ix = round(fx);
 	iz = round(fz);
 
 	var lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 6))));
 
 	var placer = new ClumpPlacer(mapArea * 0.15 * lSize, 0.7, 0.05, 10, ix, iz);
 	var terrainPainter = new LayeredPainter(
 		[tMainTerrain, tMainTerrain, tMainTerrain, tMainTerrain],		// terrains
 		[1, 4, 2]		// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		-3,				// elevation
 		4				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer,floor(scaleByMapSize(15,25))));
 }
 //********************************************************************************************************
 else if (md == 8) //lakes
 {
 
 	// randomize player order
 	var playerIDs = [];
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerIDs.push(i+1);
 	}
 	playerIDs = sortPlayers(playerIDs);
 
 	// place players
 
 	var playerX = new Array(numPlayers);
 	var playerZ = new Array(numPlayers);
 	var playerAngle = new Array(numPlayers);
 
 	var startAngle = randFloat(0, TWO_PI);
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerAngle[i] = startAngle + i*TWO_PI/numPlayers;
 		playerX[i] = 0.5 + 0.35*cos(playerAngle[i]);
 		playerZ[i] = 0.5 + 0.35*sin(playerAngle[i]);
 	}
 
 	for (var ix = 0; ix < mapSize; ix++)
 	{
 		for (var iz = 0; iz < mapSize; iz++)
 		{
 			var x = ix / (mapSize + 1.0);
 			var z = iz / (mapSize + 1.0);
 				setHeight(ix, iz, 3);
 		}
 	}
 
 	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 = scaleByMapSize(17,29)/3;
 		placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 		createArea(placer, paintClass(clPlayer), null);
 	}
 
 	// create lakes
 	log("Creating lakes...");
 	placer = new ClumpPlacer(scaleByMapSize(160, 700), 0.2, 0.1, 1);
 	terrainPainter = new LayeredPainter(
 		[tShore, tWater, tWater],		// terrains
 		[1, 3]								// widths
 	);
 	elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -5, 5);
 	if (randInt(1,2) == 1)
 	{
 		createAreas(
 			placer,
 			[terrainPainter, elevationPainter, paintClass(clWater)],
 			avoidClasses(clPlayer, 12, clWater, 8),
 			scaleByMapSize(5, 16)
 		);
 	}
 	else
 	{
 		createAreas(
 			placer,
 			[terrainPainter, elevationPainter, paintClass(clWater)],
 			avoidClasses(clPlayer, 12),
 			scaleByMapSize(5, 16)
 		);
 	}
 }
 //********************************************************************************************************
 else if (md == 9) //passes
 {
 
 	// randomize player order
 	var playerIDs = [];
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerIDs.push(i+1);
 	}
 	playerIDs = sortPlayers(playerIDs);
 
 	// place players
 
 	var playerX = new Array(numPlayers);
 	var playerZ = new Array(numPlayers);
 	var playerAngle = new Array(numPlayers);
 
 	var startAngle = randFloat(0, TWO_PI);
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerAngle[i] = startAngle + i*TWO_PI/numPlayers;
 		playerX[i] = 0.5 + 0.35*cos(playerAngle[i]);
 		playerZ[i] = 0.5 + 0.35*sin(playerAngle[i]);
 	}
 
 	for (var ix = 0; ix < mapSize; ix++)
 	{
 		for (var iz = 0; iz < mapSize; iz++)
 		{
 			var x = ix / (mapSize + 1.0);
 			var z = iz / (mapSize + 1.0);
 				setHeight(ix, iz, 3);
 		}
 	}
 
 	//create ranges
 	log ("Creating ranges...");
 	for (var m = 0; m < numPlayers; m++)
 	{
 		var tang = startAngle + (m+0.5)*TWO_PI/(numPlayers);
 		var placer = new PathPlacer(fractionToTiles(0.5), fractionToTiles(0.5), fractionToTiles(0.5 + 0.49*cos(tang)), fractionToTiles(0.5 + 0.49*sin(tang)), scaleByMapSize(14,24), 0.4, 3*(scaleByMapSize(1,3)), 0.2, 0.05);
 		var terrainPainter = new LayeredPainter(
 			[tShore, tWater, tWater],		// terrains
 			[1, 3]								// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			24,				// elevation
 			3				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 5));
 		placer = new ClumpPlacer(floor(PI*scaleByMapSize(10,50)*scaleByMapSize(10,50)/5), 0.95, 0.6, 10, fractionToTiles(0.5 + 0.49*cos(tang)), fractionToTiles(0.5 + 0.49*sin(tang)));
 		var painter = new LayeredPainter([tWater, tWater], [1]);
 		var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 24, 0);
 		createArea(placer, [painter, elevationPainter], avoidClasses(clPlayer, 5));
 
 		var placer = new PathPlacer(fractionToTiles(0.5 + 0.3*cos(tang) - 0.1 * cos(tang+PI/2)), fractionToTiles(0.5 + 0.3*sin(tang) - 0.1 * sin(tang+PI/2)), fractionToTiles(0.5 + 0.3*cos(tang) + 0.1 * cos(tang+PI/2)), fractionToTiles(0.5 + 0.3*sin(tang) + 0.1 * sin(tang+PI/2)), scaleByMapSize(14,24), 0.4, 3*(scaleByMapSize(1,3)), 0.2, 0.05);
 		var painter = new LayeredPainter([tCliff, tCliff], [1]);
 		var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 2);
 		createArea(placer, [painter, elevationPainter], null);
 	}
 	var mdd1 = randInt (1,3);
 	if (mdd1 <= 2)
 	{
 		var fx = fractionToTiles(0.5);
 		var fz = fractionToTiles(0.5);
 		ix = round(fx);
 		iz = round(fz);
 
 		var placer = new ClumpPlacer(mapArea * 0.005, 0.7, 0.1, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tShore, tWater, tWater, tWater],		// terrains
 			[1, 4, 2]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			24,				// elevation
 			4				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], null);
 	}
 	else
 	{
 		var fx = fractionToTiles(0.5);
 		var fz = fractionToTiles(0.5);
 		ix = round(fx);
 		iz = round(fz);
 
 		var lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 6))));
 
 		var placer = new ClumpPlacer(mapArea * 0.03 * lSize, 0.7, 0.1, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tShore, tWater, tWater, tWater],		// terrains
 			[1, 4, 2]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			-4,				// elevation
 			3				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], null);
 	}
 }
 //********************************************************************************************************
 else if (md == 10) //lowlands
 {
 	// randomize player order
 	var playerIDs = [];
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerIDs.push(i+1);
 	}
 	playerIDs = sortPlayers(playerIDs);
 
 	// place players
 
 	var playerX = new Array(numPlayers);
 	var playerZ = new Array(numPlayers);
 	var playerAngle = new Array(numPlayers);
 
 	var startAngle = randFloat(0, TWO_PI);
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerAngle[i] = startAngle + i*TWO_PI/numPlayers;
 		playerX[i] = 0.5 + 0.35*cos(playerAngle[i]);
 		playerZ[i] = 0.5 + 0.35*sin(playerAngle[i]);
 	}
 
 	for (var ix = 0; ix < mapSize; ix++)
 	{
 		for (var iz = 0; iz < mapSize; iz++)
 		{
 			var x = ix / (mapSize + 1.0);
 			var z = iz / (mapSize + 1.0);
 				setHeight(ix, iz, 30);
 		}
 	}
 
 
 	var radius = scaleByMapSize(18,32);
 	var cliffRadius = 2;
 	var elevation = 20;
 	var hillSize = PI * radius * radius;
 
 	var split = 1;
 	if ((mapSize / 64 == 2)&&(numPlayers <= 2))
 	{
 		split = 2;
 	}
 	else if ((mapSize / 64 == 3)&&(numPlayers <= 3))
 	{
 		split = 2;
 	}
 	else if ((mapSize / 64 == 4)&&(numPlayers <= 4))
 	{
 		split = 2;
 	}
 	else if ((mapSize / 64 == 5)&&(numPlayers <= 4))
 	{
 		split = 2;
 	}
 	else if ((mapSize / 64 == 6)&&(numPlayers <= 5))
 	{
 		split = 2;
 	}
 	else if ((mapSize / 64 == 7)&&(numPlayers <= 6))
 	{
 		split = 2;
 	}
 
 	for (var i = 0; i < numPlayers*split; i++)
 	{
 		var tang = startAngle + (i)*TWO_PI/(numPlayers*split);
 		var fx = fractionToTiles(0.5 + 0.35*cos(tang));
 		var fz = fractionToTiles(0.5 + 0.35*sin(tang));
 		var ix = round(fx);
 		var iz = round(fz);
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.65, 0.1, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tMainTerrain, tMainTerrain],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			3,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 	}
 
 	var fx = fractionToTiles(0.5);
 	var fz = fractionToTiles(0.5);
 	ix = round(fx);
 	iz = round(fz);
 
 	var lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 6))));
 
 	var placer = new ClumpPlacer(mapArea * 0.091 * lSize, 0.7, 0.1, 10, ix, iz);
 	var terrainPainter = new LayeredPainter(
 		[tMainTerrain, tMainTerrain, tMainTerrain, tMainTerrain],		// terrains
 		[1, 4, 2]		// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		3,				// elevation
 		4				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], null);
 
 	for (var m = 0; m < numPlayers*split; m++)
 	{
 		var tang = startAngle + m*TWO_PI/(numPlayers*split);
 		var placer = new PathPlacer(fractionToTiles(0.5), fractionToTiles(0.5), fractionToTiles(0.5 + 0.35*cos(tang)), fractionToTiles(0.5 + 0.35*sin(tang)), scaleByMapSize(14,24), 0.4, 3*(scaleByMapSize(1,3)), 0.2, 0.05);
 		var terrainPainter = new LayeredPainter(
 			[tMainTerrain, tMainTerrain, tMainTerrain],		// terrains
 			[1, 3]								// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			3,				// elevation
 			4				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], null);
 	}
 }
 //********************************************************************************************************
 else //mainland
 {
 
 	// randomize player order
 	var playerIDs = [];
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerIDs.push(i+1);
 	}
 	playerIDs = sortPlayers(playerIDs);
 
 	// place players
 
 	var playerX = new Array(numPlayers);
 	var playerZ = new Array(numPlayers);
 	var playerAngle = new Array(numPlayers);
 
 	var startAngle = randFloat(0, TWO_PI);
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerAngle[i] = startAngle + i*TWO_PI/numPlayers;
 		playerX[i] = 0.5 + 0.35*cos(playerAngle[i]);
 		playerZ[i] = 0.5 + 0.35*sin(playerAngle[i]);
 	}
 
 	for (var ix = 0; ix < mapSize; ix++)
 	{
 		for (var iz = 0; iz < mapSize; iz++)
 		{
 			var x = ix / (mapSize + 1.0);
 			var z = iz / (mapSize + 1.0);
 				setHeight(ix, iz, 3);
 		}
 	}
 
 }
 
 paintTerrainBasedOnHeight(3.12, 40, 1, tCliff);
 paintTerrainBasedOnHeight(3, 3.12, 1, tMainTerrain);
 paintTerrainBasedOnHeight(1, 3, 1, tShore);
 paintTerrainBasedOnHeight(-8, 1, 2, tWater);
 unPaintTileClassBasedOnHeight(0, 3.12, 1, clWater);
 unPaintTileClassBasedOnHeight(-6, 0, 1, clLand);
 paintTileClassBasedOnHeight(-6, 0, 1, clWater);
 paintTileClassBasedOnHeight(0, 3.12, 1, clLand);
 paintTileClassBasedOnHeight(3.12, 40, 1, clHill);
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	// some constants
 	var radius = scaleByMapSize(17,29);
 	var shoreRadius = 4;
 	var elevation = 3;
 
 	var hillSize = PI * radius * radius;
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 
 	// create starting units
 	if (iberianTowers)
 		placeCivDefaultEntities(fx, fz, id, { 'iberWall': 'towers' });
 	else
 		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);
 	if (needsAdditionalWood)
 	{
 		// create woods
 		var bbAngle = randFloat(0, TWO_PI);
 		var bbDist = 13;
 		var bbX = round(fx + bbDist * cos(bbAngle));
 		var bbZ = round(fz + bbDist * sin(bbAngle));
 		group = new SimpleGroup(
 			[new SimpleObject(oWood, 14,14, 0,3)],
 			true, clBaseResource, bbX, bbZ
 		);
 		createObjectGroup(group, 0);
 	}
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 	var hillSize = PI * radius * radius;
 	// create starting trees
 	var num = 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);
 }
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 	// create the city patch
 	var cityRadius = radius/3;
 	placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tRoadWild, tRoad], [1]);
 	createArea(placer, [painter, paintClass(clPlayer)], null);
 }
 
 // create bumps
 log("Creating bumps...");
 placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1);
 painter = new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2);
 createAreas(
 	placer,
 	painter,
 	[avoidClasses(clWater, 2, clPlayer, 10), stayClasses(clLand, 3)],
 	randInt(0,scaleByMapSize(200, 400))
 );
 
 // create hills
 log("Creating hills...");
 placer = new ClumpPlacer(scaleByMapSize(20, 150), 0.2, 0.1, 1);
 terrainPainter = new LayeredPainter(
 	[tCliff, tHill],		// terrains
 	[2]								// widths
 );
 elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 18, 2);
 createAreas(
 	placer,
 	[terrainPainter, elevationPainter, paintClass(clHill)],
 	[avoidClasses(clPlayer, 20, clHill, randInt(6, 18)), stayClasses(clLand, 0)],
 	randInt(0, scaleByMapSize(4, 8))*randInt(1, scaleByMapSize(4, 9))
 );
 
 var multiplier = sqrt(randFloat(0.5,1.2)*randFloat(0.5,1.2));
 // calculate desired number of trees for map (based on size)
 if (random_terrain == g_BiomeSavanna)
 {
 	var MIN_TREES = floor(200*multiplier);
 	var MAX_TREES = floor(1250*multiplier);
 	var P_FOREST = randFloat(0.02, 0.05);
 }
 else if (random_terrain == g_BiomeTropic)
 {
 	var MIN_TREES = floor(1000*multiplier);
 	var MAX_TREES = floor(6000*multiplier);
 	var P_FOREST = randFloat(0.5, 0.7);
 }
 else
 {
 	var MIN_TREES = floor(500*multiplier);
 	var MAX_TREES = floor(3000*multiplier);
 	var P_FOREST = randFloat(0.5,0.8);
 }
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 var numForest = totalTrees * P_FOREST;
 var numStragglers = totalTrees * (1.0 - P_FOREST);
 
 // create forests
 log("Creating forests...");
 var types = [
 	[[tForestFloor2, tMainTerrain, pForest1], [tForestFloor2, pForest1]],
 	[[tForestFloor1, tMainTerrain, pForest2], [tForestFloor1, pForest2]]
 ];	// some variation
 
 if (random_terrain == g_BiomeSavanna)
 	var size = numForest / (0.5 * scaleByMapSize(2,8) * numPlayers);
 else
 	var size = numForest / (scaleByMapSize(2,8) * numPlayers);
 
 var num = floor(size / types.length);
 for (var i = 0; i < types.length; ++i)
 {
 	placer = new ClumpPlacer(numForest / num, 0.1, 0.1, 1);
 	painter = new LayeredPainter(
 		types[i],		// terrains
 		[2]											// widths
 		);
 	createAreas(
 		placer,
 		[painter, paintClass(clForest)],
 		[avoidClasses(clPlayer, 20, clForest, randInt(5, 15), clHill, 0), stayClasses(clLand, 4)],
 		num
 	);
 }
 
 RMS.SetProgress(50);
 // create dirt patches
 log("Creating dirt patches...");
 var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
 var numb = 1;
 if (random_terrain == g_BiomeSavanna)
 	numb = 3;
 for (var i = 0; i < sizes.length; i++)
 {
 	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
 	painter = new LayeredPainter(
 		[[tMainTerrain,tTier1Terrain],[tTier1Terrain,tTier2Terrain], [tTier2Terrain,tTier3Terrain]], 		// terrains
 		[1,1]															// widths
 	);
 	createAreas(
 		placer,
 		[painter, paintClass(clDirt)],
 		[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 7), stayClasses(clLand, 4)],
 		numb*scaleByMapSize(15, 45)
 	);
 }
 
 // create grass patches
 log("Creating grass patches...");
 var sizes = [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)];
 for (var i = 0; i < sizes.length; i++)
 {
 	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
 	painter = new TerrainPainter(tTier4Terrain);
 	createAreas(
 		placer,
 		painter,
 		[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 7), stayClasses(clLand, 4)],
 		numb*scaleByMapSize(15, 45)
 	);
 }
 RMS.SetProgress(55);
 
 
 log("Creating stone mines...");
 // create large stone quarries
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
 createObjectGroups(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 20, clRock, 10, clHill, 1), stayClasses(clLand, 4)],
 	randInt(scaleByMapSize(2,9),scaleByMapSize(9,40)), 100
 );
 
 // create small stone quarries
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroups(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 20, clRock, 10, clHill, 1), stayClasses(clLand, 4)],
 	randInt(scaleByMapSize(2,9),scaleByMapSize(9,40)), 100
 );
 
 log("Creating metal mines...");
 // create large metal quarries
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroups(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 1), stayClasses(clLand, 4)],
 	randInt(scaleByMapSize(2,9),scaleByMapSize(9,40)), 100
 );
 
 RMS.SetProgress(65);
 
 // create small decorative rocks
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockMedium, 1,3, 0,1)],
 	true
 );
 createObjectGroups(
 	group, 0,
 	[avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 4)],
 	scaleByMapSize(16, 262), 50
 );
 
 
 // create large decorative rocks
 log("Creating large decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
 	true
 );
 createObjectGroups(
 	group, 0,
 	[avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 4)],
 	scaleByMapSize(8, 131), 50
 );
 
 RMS.SetProgress(70);
 
 // create deer
 log("Creating deer...");
 group = new SimpleGroup(
 	[new SimpleObject(oMainHuntableAnimal, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clWater, 0, clForest, 0, clPlayer, 20, clHill, 1, clFood, 20), stayClasses(clLand, 4)],
 	randInt(numPlayers+3, 5*numPlayers+4), 50
 );
 
 // create berry bush
 log("Creating berry bush...");
 group = new SimpleGroup(
 	[new SimpleObject(oFruitBush, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clWater, 0, clForest, 0, clPlayer, 20, clHill, 1, clFood, 20), stayClasses(clLand, 4)],
 	randInt(1, 4) * numPlayers + 2, 50
 );
 
 RMS.SetProgress(75);
 
 // create sheep
 log("Creating sheep...");
 group = new SimpleGroup(
 	[new SimpleObject(oSecondaryHuntableAnimal, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clWater, 0, clForest, 0, clPlayer, 20, clHill, 1, clFood, 20), stayClasses(clLand, 4)],
 	randInt(numPlayers+3, 5*numPlayers+4), 50
 );
 
 // create fish
 log("Creating fish...");
 group = new SimpleGroup(
 	[new SimpleObject(oFish, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroups(group, 0,
 	avoidClasses(clLand, 5, clForest, 0, clPlayer, 0, clHill, 0, clFood, 20),
 	randInt(15, 40) * numPlayers, 60
 );
 
 RMS.SetProgress(85);
 
 
 // create straggler trees
 log("Creating straggler trees...");
 var types = [oTree1, oTree2, oTree4, oTree3];	// some variation
 var num = floor(numStragglers / types.length);
 for (var i = 0; i < types.length; ++i)
 {
 	group = new SimpleGroup(
 		[new SimpleObject(types[i], 1,1, 0,3)],
 		true, clForest
 	);
 	createObjectGroups(group, 0,
 		[avoidClasses(clWater, 1, clForest, 1, clHill, 1, clPlayer, 0, clMetal, 6, clRock, 6), stayClasses(clLand, 4)],
 		num
 	);
 }
 
 var planetm = 1;
 if (random_terrain == g_BiomeTropic)
 	planetm = 8;
 
 //create small grass tufts
 log("Creating small grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)]
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clWater, 2, clHill, 2, clPlayer, 2, clDirt, 0), stayClasses(clLand, 4)],
 	planetm * scaleByMapSize(13, 200)
 );
 
 RMS.SetProgress(90);
 
 // create large grass tufts
 log("Creating large grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aGrass, 2,4, 0,1.8, -PI/8,PI/8), new SimpleObject(aGrassShort, 3,6, 1.2,2.5, -PI/8,PI/8)]
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clWater, 3, clHill, 2, clPlayer, 2, clDirt, 1, clForest, 0), stayClasses(clLand, 4)],
 	planetm * scaleByMapSize(13, 200)
 );
 
 RMS.SetProgress(95);
 
 // create shallow flora
 log("Creating shallow flora...");
 group = new SimpleGroup(
 	[new SimpleObject(aLillies, 1,2, 0,2), new SimpleObject(aReeds, 2,4, 0,2)]
 );
 createObjectGroups(group, 0,
 	stayClasses(clShallow, 1),
 	60 * scaleByMapSize(13, 200), 80
 );
 
 // create bushes
 log("Creating bushes...");
 group = new SimpleGroup(
 	[new SimpleObject(aBushMedium, 1,2, 0,2), new SimpleObject(aBushSmall, 2,4, 0,2)]
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clWater, 1, clHill, 1, clPlayer, 1, clDirt, 1), stayClasses(clLand, 3)],
 	planetm * scaleByMapSize(13, 200), 50
 );
 
-random_terrain = randInt(1,6);
-if (random_terrain == 1)
-	setSkySet("cirrus");
-else if (random_terrain == 2)
-	setSkySet("cumulus");
-else if (random_terrain == 3)
-	setSkySet("sunny");
-else if (random_terrain == 4)
-	setSkySet("sunny 1");
-else if (random_terrain == 5)
-	setSkySet("mountainous");
-else if (random_terrain == 6)
-	setSkySet("stratus");
-
+setSkySet(pickRandom(["cirrus", "cumulus", "sunny", "sunny 1", "mountainous", "stratus"]));
 setSunRotation(randFloat(0, TWO_PI));
 setSunElevation(randFloat(PI/ 5, PI / 3));
 
 // Export map data
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/unknown_land.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/unknown_land.js	(revision 19285)
+++ ps/trunk/binaries/data/mods/public/maps/random/unknown_land.js	(revision 19286)
@@ -1,1808 +1,1795 @@
 RMS.LoadLibrary("rmgen");
 
 TILE_CENTERED_HEIGHT_MAP = true;
 //random terrain textures
 var random_terrain = randomizeBiome();
 
 const tMainTerrain = rBiomeT1();
 const tForestFloor1 = rBiomeT2();
 const tForestFloor2 = rBiomeT3();
 const tCliff = rBiomeT4();
 const tTier1Terrain = rBiomeT5();
 const tTier2Terrain = rBiomeT6();
 const tTier3Terrain = rBiomeT7();
 const tHill = rBiomeT8();
 const tDirt = rBiomeT9();
 const tRoad = rBiomeT10();
 const tRoadWild = rBiomeT11();
 const tTier4Terrain = rBiomeT12();
 const tShoreBlend = rBiomeT13();
 const tShore = rBiomeT14();
 const tWater = rBiomeT15();
 
 // gaia entities
 const oTree1 = rBiomeE1();
 const oTree2 = rBiomeE2();
 const oTree3 = rBiomeE3();
 const oTree4 = rBiomeE4();
 const oTree5 = rBiomeE5();
 const oFruitBush = rBiomeE6();
 const oMainHuntableAnimal = rBiomeE8();
 const oFish = rBiomeE9();
 const oSecondaryHuntableAnimal = rBiomeE10();
 const oStoneLarge = rBiomeE11();
 const oStoneSmall = rBiomeE12();
 const oMetalLarge = rBiomeE13();
 const oWood = "gaia/special_treasure_wood";
 
 // decorative props
 const aGrass = rBiomeA1();
 const aGrassShort = rBiomeA2();
 const aReeds = rBiomeA3();
 const aLillies = rBiomeA4();
 const aRockLarge = rBiomeA5();
 const aRockMedium = rBiomeA6();
 const aBushMedium = rBiomeA7();
 const aBushSmall = rBiomeA8();
 
 const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
 const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
 
 log("Initializing map...");
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 const mapArea = mapSize*mapSize;
 
 // create tile classes
 
 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 clSettlement = createTileClass();
 var clLand = createTileClass();
 var clShallow = createTileClass();
 
 for (var ix = 0; ix < mapSize; ix++)
 {
 	for (var iz = 0; iz < mapSize; iz++)
 	{
 		var x = ix / (mapSize + 1.0);
 		var z = iz / (mapSize + 1.0);
 			placeTerrain(ix, iz, tWater);
 	}
 }
 
 var md = randInt(2,13);
 var needsAdditionalWood = false;
 //*****************************************************************************************************************************
 if (md == 2) //continent
 {
 
 	// randomize player order
 	var playerIDs = [];
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerIDs.push(i+1);
 	}
 	playerIDs = sortPlayers(playerIDs);
 
 	// place players
 
 	var playerX = new Array(numPlayers);
 	var playerZ = new Array(numPlayers);
 	var playerAngle = new Array(numPlayers);
 
 	var startAngle = randFloat(0, TWO_PI);
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerAngle[i] = startAngle + i*TWO_PI/numPlayers;
 		playerX[i] = 0.5 + 0.25*cos(playerAngle[i]);
 		playerZ[i] = 0.5 + 0.25*sin(playerAngle[i]);
 
 		var fx = fractionToTiles(playerX[i]);
 		var fz = fractionToTiles(playerZ[i]);
 		var ix = round(fx);
 		var iz = round(fz);
 		addToClass(ix, iz, clPlayer);
 		addToClass(ix+5, iz, clPlayer);
 		addToClass(ix, iz+5, clPlayer);
 		addToClass(ix-5, iz, clPlayer);
 		addToClass(ix, iz-5, clPlayer);
 
 		var placer = new ChainPlacer(2, floor(scaleByMapSize(5, 9)), floor(scaleByMapSize(5, 20)), 1, ix, iz, 0, [floor(scaleByMapSize(23, 50))]);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			3,				// elevation
 			4				// blend radius
 		);
 		createArea(placer, [elevationPainter, paintClass(clLand)], null);
 	}
 
 	var fx = fractionToTiles(0.5);
 	var fz = fractionToTiles(0.5);
 	ix = round(fx);
 	iz = round(fz);
 
 	var placer = new ChainPlacer(2, floor(scaleByMapSize(5, 12)), floor(scaleByMapSize(60, 700)), 1, ix, iz, 0, [floor(mapSize * 0.33)]);
 	var terrainPainter = new LayeredPainter(
 		[tWater, tShore, tMainTerrain],		// terrains
 		[4, 2]		// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		3,				// elevation
 		4				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 	var clPeninsulaSteam = createTileClass();
 
 	if (randInt(1,3)==1) // peninsula
 	{
 		var angle = randFloat(0, TWO_PI);
 
 		var fx = fractionToTiles(0.5 + 0.25*cos(angle));
 		var fz = fractionToTiles(0.5 + 0.25*sin(angle));
 		ix = round(fx);
 		iz = round(fz);
 
 		var placer = new ChainPlacer(2, floor(scaleByMapSize(5, 12)), floor(scaleByMapSize(60, 700)), 1, ix, iz, 0, [floor(mapSize * 0.33)]);
 		var terrainPainter = new LayeredPainter(
 			[tWater, tShore, tMainTerrain],		// terrains
 			[4, 2]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			3,				// elevation
 			4				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 		var fx = fractionToTiles(0.5 + 0.35*cos(angle));
 		var fz = fractionToTiles(0.5 + 0.35*sin(angle));
 		ix = round(fx);
 		iz = round(fz);
 
 		var placer = new ClumpPlacer(mapArea * 0.3, 0.9, 0.01, 10, ix, iz);
 		createArea(placer, [paintClass(clPeninsulaSteam)], null);
 	}
 }
 //********************************************************************************************************
 else if (md == 3) //central sea
 {
 // randomize player order
 var playerIDs = [];
 for (var i = 0; i < numPlayers; i++)
 {
 	playerIDs.push(i+1);
 }
 playerIDs = primeSortPlayers(sortPlayers(playerIDs));
 
 	// place players
 
 	var playerX = new Array(numPlayers);
 	var playerZ = new Array(numPlayers);
 	var playerAngle = new Array(numPlayers);
 	var playerPos = new Array(numPlayers);
 	var iop = 0;
 
 	var mdd1 = randInt(1,2);
 	if (mdd1 == 1) //vertical
 	{
 		for (var i = 0; i < numPlayers; i++)
 		{
 			iop = i - 1;
 			if (!(numPlayers%2)){
 				playerPos[i] = ((iop + abs(iop%2))/2 + 1) / ((numPlayers / 2) + 1);
 			}
 			else
 			{
 				if (iop%2)
 				{
 					playerPos[i] = ((iop + abs(iop%2))/2 + 1) / (((numPlayers + 1) / 2) + 1);
 				}
 				else
 				{
 					playerPos[i] = ((iop)/2 + 1) / ((((numPlayers - 1)) / 2) + 1);
 				}
 			}
 			playerZ[i] = playerPos[i];
 			playerX[i] = 0.2 + 0.6*(i%2);
 		}
 	}
 	else //horizontal
 	{
 		for (var i = 0; i < numPlayers; i++)
 		{
 			iop = i - 1;
 			if (!(numPlayers%2)){
 				playerPos[i] = ((iop + abs(iop%2))/2 + 1) / ((numPlayers / 2) + 1);
 			}
 			else
 			{
 				if (iop%2)
 				{
 					playerPos[i] = ((iop + abs(iop%2))/2 + 1) / (((numPlayers + 1) / 2) + 1);
 				}
 				else
 				{
 					playerPos[i] = ((iop)/2 + 1) / ((((numPlayers - 1)) / 2) + 1);
 				}
 			}
 			playerZ[i] = 0.2 + 0.6*(i%2);
 			playerX[i] = playerPos[i];
 		}
 	}
 
 
 	var WATER_WIDTH = randFloat(0.22,0.3)+scaleByMapSize(1,4)/20;
 	log("Creating sea");
 	var theta = randFloat(0, 1);
 	var theta2 = randFloat(0, 1);
 	var seed = randFloat(2,3);
 	var seed2 = randFloat(2,3);
 	for (var ix = 0; ix < mapSize; ix++)
 	{
 		for (var iz = 0; iz < mapSize; iz++)
 		{
 			var x = ix / (mapSize + 1.0);
 			var z = iz / (mapSize + 1.0);
 
 			// add the rough shape of the water
 			var km = 20/scaleByMapSize(35, 160);
 
 			var fadeDist = 0.05;
 
 			if (mdd1 == 1) //vertical
 			{
 				var cu = km*rndRiver(theta+z*0.5*(mapSize/64),seed);
 				var cu2 = km*rndRiver(theta2+z*0.5*(mapSize/64),seed2);
 
 				if ((x > cu + 0.5 - WATER_WIDTH/2) && (x < cu2 + 0.5 + WATER_WIDTH/2))
 				{
 					var h;
 					if (x < (cu + 0.5 + fadeDist - WATER_WIDTH/2))
 					{
 						h = 3 - 6 * (1 - ((cu + 0.5 + fadeDist - WATER_WIDTH/2) - x)/fadeDist);
 					}
 					else if (x > (cu2 + 0.5 - fadeDist + WATER_WIDTH/2))
 					{
 						h = 3 - 6 * (1 - (x - (cu2 + 0.5 - fadeDist + WATER_WIDTH/2))/fadeDist);
 					}
 					else
 					{
 						h = -3.0;
 					}
 
 					if (h < -1.5)
 					{
 						placeTerrain(ix, iz, tWater);
 					}
 					else
 					{
 						placeTerrain(ix, iz, tShore);
 					}
 
 					setHeight(ix, iz, h);
 					if (h < 0){
 						addToClass(ix, iz, clWater);
 					}
 				}
 				else
 				{
 					setHeight(ix, iz, 3.1);
 					addToClass(ix, iz, clLand);
 				}
 			}
 			else //horizontal
 			{
 				var cu = km*rndRiver(theta+x*0.5*(mapSize/64),seed);
 				var cu2 = km*rndRiver(theta2+x*0.5*(mapSize/64),seed2);
 
 				if ((z > cu + 0.5 - WATER_WIDTH/2) && (z < cu2 + 0.5 + WATER_WIDTH/2))
 				{
 					var h;
 					if (z < (cu + 0.5 + fadeDist - WATER_WIDTH/2))
 					{
 						h = 3 - 6 * (1 - ((cu + 0.5 + fadeDist - WATER_WIDTH/2) - z)/fadeDist);
 					}
 					else if (z > (cu2 + 0.5 - fadeDist + WATER_WIDTH/2))
 					{
 						h = 3 - 6 * (1 - (z - (cu2 + 0.5 - fadeDist + WATER_WIDTH/2))/fadeDist);
 					}
 					else
 					{
 						h = -3.0;
 					}
 
 					if (h < -1.5)
 					{
 						placeTerrain(ix, iz, tWater);
 					}
 					else
 					{
 						placeTerrain(ix, iz, tShore);
 					}
 
 					setHeight(ix, iz, h);
 					if (h < 0){
 						addToClass(ix, iz, clWater);
 					}
 				}
 				else
 				{
 					setHeight(ix, iz, 3.1);
 					addToClass(ix, iz, clLand);
 				}
 			}
 		}
 	}
 
 
 	// linked
 	if (mdd1 == 1) //vertical
 	{
 		var placer = new PathPlacer(1, fractionToTiles(0.5), fractionToTiles(0.99), fractionToTiles(0.5), scaleByMapSize(randInt(16,24),randInt(100,140)), 0.5, 3*(scaleByMapSize(1,4)), 0.1, 0.01);
 	}
 	else
 	{
 		var placer = new PathPlacer(fractionToTiles(0.5), 1, fractionToTiles(0.5), fractionToTiles(0.99), scaleByMapSize(randInt(16,24),randInt(100,140)), 0.5, 3*(scaleByMapSize(1,4)), 0.1, 0.01);
 	}
 	var terrainPainter = new LayeredPainter(
 		[tMainTerrain, tMainTerrain, tMainTerrain],		// terrains
 		[1, 3]								// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		3.1,				// elevation
 		4				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, unPaintClass(clWater)], null);
 
 	var mdd2 = randInt(1,7);
 	if (mdd2 == 1)
 	{
 		// create islands
 		log("Creating islands...");
 		placer = new ChainPlacer(floor(scaleByMapSize(4, 7)), floor(scaleByMapSize(7, 10)), floor(scaleByMapSize(16, 40)), 0.07);
 		terrainPainter = new LayeredPainter(
 			[tMainTerrain, tMainTerrain],		// terrains
 			[2]								// widths
 		);
 		elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3.1, 4);
 		createAreas(
 			placer,
 			[terrainPainter, elevationPainter, paintClass(clLand)],
 			avoidClasses(clLand, 3, clPlayer, 3),
 			scaleByMapSize(2, 5)*randInt(8,14)
 		);
 	}
 	else if (mdd2 == 2)
 	{
 		// create extentions
 		log("Creating extentions...");
 		placer = new ClumpPlacer(randInt(scaleByMapSize(13,24),scaleByMapSize(24,45))*randInt(scaleByMapSize(13,24),scaleByMapSize(24,45)), 0.80, 0.1, 10);
 		terrainPainter = new LayeredPainter(
 			[tMainTerrain, tMainTerrain],		// terrains
 			[2]								// widths
 		);
 		elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3.1, 4);
 		createAreas(
 			placer,
 			[terrainPainter, elevationPainter, paintClass(clLand)],
 			null,
 			scaleByMapSize(2, 5)*randInt(8,14)
 		);
 	}
 }
 //********************************************************************************************************
 else if (md == 4) //central river
 {
 
 	for (var ix = 0; ix < mapSize; ix++)
 	{
 		for (var iz = 0; iz < mapSize; iz++)
 		{
 			var x = ix / (mapSize + 1.0);
 			var z = iz / (mapSize + 1.0);
 				setHeight(ix, iz, 3);
 		}
 	}
 
 	// randomize player order
 	var playerIDs = [];
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerIDs.push(i+1);
 	}
 	playerIDs = primeSortPlayers(sortPlayers(playerIDs));
 
 	// place players
 
 	var playerX = new Array(numPlayers);
 	var playerZ = new Array(numPlayers);
 	var playerAngle = new Array(numPlayers);
 	var playerPos = new Array(numPlayers);
 	var iop = 0;
 	var mdd1 = randInt(1,2);
 	if (mdd1 == 1) //horizontal
 	{
 		for (var i = 0; i < numPlayers; i++)
 		{
 			iop = i - 1;
 			if (!(numPlayers%2)){
 				playerPos[i] = ((iop + abs(iop%2))/2 + 1) / ((numPlayers / 2) + 1);
 			}
 			else
 			{
 				if (iop%2)
 				{
 					playerPos[i] = ((iop + abs(iop%2))/2 + 1) / (((numPlayers + 1) / 2) + 1);
 				}
 				else
 				{
 					playerPos[i] = ((iop)/2 + 1) / ((((numPlayers - 1)) / 2) + 1);
 				}
 			}
 
 			playerZ[i] = 0.25 + 0.5*(i%2);
 			playerX[i] = playerPos[i];
 		}
 	}
 	else //vertical
 	{
 		for (var i = 0; i < numPlayers; i++)
 		{
 			iop = i - 1;
 			if (!(numPlayers%2)){
 				playerPos[i] = ((iop + abs(iop%2))/2 + 1) / ((numPlayers / 2) + 1);
 			}
 			else
 			{
 				if (iop%2)
 				{
 					playerPos[i] = ((iop + abs(iop%2))/2 + 1) / (((numPlayers + 1) / 2) + 1);
 				}
 				else
 				{
 					playerPos[i] = ((iop)/2 + 1) / ((((numPlayers - 1)) / 2) + 1);
 				}
 			}
 
 			playerZ[i] = playerPos[i];
 			playerX[i] = 0.25 + 0.5*(i%2);
 		}
 	}
 
 	// create the main river
 	log("Creating the main river");
 
 	if (mdd1 == 2)
 		var placer = new PathPlacer(fractionToTiles(0.5), 1, fractionToTiles(0.5) , fractionToTiles(0.99), scaleByMapSize(14,24), 0.5, 3*(scaleByMapSize(1,4)), 0.1, 0.01);
 	else
 		var placer = new PathPlacer(1, fractionToTiles(0.5), fractionToTiles(0.99), fractionToTiles(0.5), scaleByMapSize(14,24), 0.5, 3*(scaleByMapSize(1,4)), 0.1, 0.01);
 
 	var terrainPainter = new LayeredPainter(
 		[tShore, tWater, tWater],		// terrains
 		[1, 3]								// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		-4,				// elevation
 		4				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter], avoidClasses(clPlayer, 4));
 
 	if (mdd1 == 1)
 		placer = new ClumpPlacer(floor(PI*scaleByMapSize(10,20)*scaleByMapSize(10,20)/4), 0.95, 0.6, 10, 1, fractionToTiles(0.5));
 	else
 		placer = new ClumpPlacer(floor(PI*scaleByMapSize(10,20)*scaleByMapSize(10,20)/4), 0.95, 0.6, 10, fractionToTiles(0.5), 1);
 
 	var painter = new LayeredPainter([tWater, tWater], [1]);
 	var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -4, 2);
 	createArea(placer, [painter, elevationPainter], avoidClasses(clPlayer, 8));
 
 	if (mdd1 == 1)
 		placer = new ClumpPlacer(floor(PI*scaleByMapSize(10,20)*scaleByMapSize(10,20)/4), 0.95, 0.6, 10, fractionToTiles(0.99), fractionToTiles(0.5));
 	else
 		placer = new ClumpPlacer(floor(PI*scaleByMapSize(10,20)*scaleByMapSize(10,20)/4), 0.95, 0.6, 10, fractionToTiles(0.5), fractionToTiles(0.99));
 
 	var painter = new LayeredPainter([tWater, tWater], [1]);
 	var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -4, 2);
 	createArea(placer, [painter, elevationPainter], avoidClasses(clPlayer, 8));
 
 	// create the shallows of the main river
 	log("Creating the shallows of the main river");
 
 	for (var i = 0; i <= randInt(1, scaleByMapSize(4,8)); i++)
 	{
 		var cLocation = randFloat(0.15,0.85);
 		if (mdd1 == 1)
 			passageMaker(floor(fractionToTiles(cLocation)), floor(fractionToTiles(0.35)), floor(fractionToTiles(cLocation)), floor(fractionToTiles(0.65)), scaleByMapSize(4,8), -2, -2, 2, clShallow, undefined, -4);
 		else
 			passageMaker(floor(fractionToTiles(0.35)), floor(fractionToTiles(cLocation)), floor(fractionToTiles(0.65)), floor(fractionToTiles(cLocation)), scaleByMapSize(4,8), -2, -2, 2, clShallow, undefined, -4);
 	}
 
 	if (randInt(1,2) == 1)
 	{
 		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 = scaleByMapSize(17,29)/3;
 			placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 			createArea(placer, paintClass(clPlayer), null);
 		}
 
 		// create tributaries
 		log("Creating tributaries");
 
 		for (var i = 0; i <= randInt(8, (scaleByMapSize(12,20))); i++)
 		{
 			var cLocation = randFloat(0.05,0.95);
 			var tang = randFloat(PI*0.2, PI*0.8)*((randInt(2)-0.5)*2);
 			if (tang > 0)
 			{
 				var cDistance = 0.05;
 			}
 			else
 			{
 				var cDistance = -0.05;
 			}
 			if (mdd1 == 1)
 				var point = getTIPIADBON([fractionToTiles(cLocation), fractionToTiles(0.5 + cDistance)], [fractionToTiles(cLocation), fractionToTiles(0.5 - cDistance)], [-6, -1.5], 0.5, 5, 0.01);
 			else
 				var point = getTIPIADBON([fractionToTiles(0.5 + cDistance), fractionToTiles(cLocation)], [fractionToTiles(0.5 - cDistance), fractionToTiles(cLocation)], [-6, -1.5], 0.5, 5, 0.01);
 
 			if (point !== undefined)
 			{
 				if (mdd1 == 1)
 					var placer = new PathPlacer(floor(point[0]), floor(point[1]), floor(fractionToTiles(0.5 + 0.49*cos(tang))), floor(fractionToTiles(0.5 + 0.49*sin(tang))), scaleByMapSize(10,20), 0.4, 3*(scaleByMapSize(1,4)), 0.1, 0.05);
 				else
 					var placer = new PathPlacer(floor(point[0]), floor(point[1]), floor(fractionToTiles(0.5 + 0.49*sin(tang))), floor(fractionToTiles(0.5 + 0.49*cos(tang))), scaleByMapSize(10,20), 0.4, 3*(scaleByMapSize(1,4)), 0.1, 0.05);
 
 
 				var terrainPainter = new LayeredPainter(
 					[tShore, tWater, tWater],		// terrains
 					[1, 3]								// widths
 				);
 				var elevationPainter = new SmoothElevationPainter(
 					ELEVATION_SET,			// type
 					-4,				// elevation
 					4				// blend radius
 				);
 				var success = createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 3, clWater, 3, clShallow, 2));
 				if (success !== undefined)
 				{
 					if (mdd1 == 1)
 						placer = new ClumpPlacer(floor(PI*scaleByMapSize(10,20)*scaleByMapSize(10,20)/4), 0.95, 0.6, 10, fractionToTiles(0.5 + 0.49*cos(tang)), fractionToTiles(0.5 + 0.49*sin(tang)));
 					else
 						placer = new ClumpPlacer(floor(PI*scaleByMapSize(10,20)*scaleByMapSize(10,20)/4), 0.95, 0.6, 10, fractionToTiles(0.5 + 0.49*sin(tang)), fractionToTiles(0.5 + 0.49*cos(tang)));
 
 					var painter = new LayeredPainter([tWater, tWater], [1]);
 					var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -4, 2);
 					createArea(placer, [painter, elevationPainter], avoidClasses(clPlayer, 3));
 				}
 			}
 		}
 	}
 }
 //********************************************************************************************************
 else if (md == 5) //rivers and lake
 {
 
 	// randomize player order
 	var playerIDs = [];
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerIDs.push(i+1);
 	}
 	playerIDs = sortPlayers(playerIDs);
 
 	// place players
 
 	var playerX = new Array(numPlayers);
 	var playerZ = new Array(numPlayers);
 	var playerAngle = new Array(numPlayers);
 
 	var startAngle = randFloat(0, TWO_PI);
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerAngle[i] = startAngle + i*TWO_PI/numPlayers;
 		playerX[i] = 0.5 + 0.35*cos(playerAngle[i]);
 		playerZ[i] = 0.5 + 0.35*sin(playerAngle[i]);
 
 		var fx = fractionToTiles(playerX[i]);
 		var fz = fractionToTiles(playerZ[i]);
 		var ix = round(fx);
 		var iz = round(fz);
 		addToClass(ix, iz, clPlayer);
 		addToClass(ix+5, iz, clPlayer);
 		addToClass(ix, iz+5, clPlayer);
 		addToClass(ix-5, iz, clPlayer);
 		addToClass(ix, iz-5, clPlayer);
 	}
 
 
 
 	for (var ix = 0; ix < mapSize; ix++)
 	{
 		for (var iz = 0; iz < mapSize; iz++)
 		{
 			var x = ix / (mapSize + 1.0);
 			var z = iz / (mapSize + 1.0);
 				setHeight(ix, iz, 3);
 		}
 	}
 	var mdd1 = randInt(1,2);
 	if (mdd1 == 1) //lake
 	{
 		var fx = fractionToTiles(0.5);
 		var fz = fractionToTiles(0.5);
 		ix = round(fx);
 		iz = round(fz);
 
 		var lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 6))));
 
 		var placer = new ChainPlacer(2, floor(scaleByMapSize(5, 16)), floor(scaleByMapSize(35, 200)), 1, ix, iz, 0, [floor(mapSize * 0.17 * lSize)]);
 		var terrainPainter = new LayeredPainter(
 			[tShore, tWater, tWater, tWater],		// terrains
 			[1, 4, 2]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			-4,				// elevation
 			4				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], null);
 
 		// create shore jaggedness
 		log("Creating shore jaggedness...");
 
 		placer = new ChainPlacer(2, floor(scaleByMapSize(4, 6)), 3, 1);
 		terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[2]								// widths
 		);
 		elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 4);
 		createAreas(
 			placer,
 			[terrainPainter, elevationPainter, unPaintClass(clWater)],
 			borderClasses(clWater, 4, 7),
 			scaleByMapSize(12, 130) * 2, 150
 		);
 	}
 
 	if ((randInt(1,3) == 1)&&(mdd1 == 1))//island
 	{
 		var placer = new ClumpPlacer(mapArea * 0.006 * lSize, 0.7, 0.1, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tShore, tWater, tWater, tWater],		// terrains
 			[1, 4, 2]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			3,				// elevation
 			4				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], null);
 	}
 }
 //********************************************************************************************************
 else if (md == 6) //edge seas
 {
 
 	for (var ix = 0; ix < mapSize; ix++)
 	{
 		for (var iz = 0; iz < mapSize; iz++)
 		{
 			var x = ix / (mapSize + 1.0);
 			var z = iz / (mapSize + 1.0);
 				setHeight(ix, iz, 3);
 		}
 	}
 
 	var mdd1 = randInt(1,2);
 
 	// randomize player order
 	var playerIDs = [];
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerIDs.push(i+1);
 	}
 	playerIDs = sortPlayers(playerIDs);
 
 	// place players
 
 	var playerX = new Array(numPlayers);
 	var playerZ = new Array(numPlayers);
 	var playerPos = new Array(numPlayers);
 
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerPos[i] = (i + 1) / (numPlayers + 1);
 		if (mdd1 == 1) //horizontal
 		{
 			playerX[i] = playerPos[i];
 			playerZ[i] = 0.4 + 0.2*(i%2);
 		}
 		else //vertical
 		{
 			playerX[i] = 0.4 + 0.2*(i%2);
 			playerZ[i] = playerPos[i];
 		}
 
 		var fx = fractionToTiles(playerX[i]);
 		var fz = fractionToTiles(playerZ[i]);
 		var ix = round(fx);
 		var iz = round(fz);
 		addToClass(ix, iz, clPlayer);
 		addToClass(ix+5, iz, clPlayer);
 		addToClass(ix, iz+5, clPlayer);
 		addToClass(ix-5, iz, clPlayer);
 		addToClass(ix, iz-5, clPlayer);
 	}
 
 	var mdd2 = randInt(1,3);
 	var fadedistance = 7;
 
 	if (mdd1 == 1)
 	{
 		if ((mdd2 == 1)||(mdd2 == 3))
 		{
 			var distance = randFloat(0., 0.1);
 			for (var ix = 0; ix < mapSize; ix++)
 			{
 				for (var iz = 0; iz < mapSize; iz++)
 				{
 					if (iz > (0.69+distance) * mapSize)
 					{
 						if (iz < (0.69+distance) * mapSize + fadedistance)
 						{
 							setHeight(ix, iz, 3 - 7 * (iz - (0.69+distance) * mapSize) / fadedistance);
 							if (3 - 7 * (iz - (0.69+distance) * mapSize) / fadedistance < 0.5)
 								addToClass(ix, iz, clWater);
 						}
 						else
 						{
 							setHeight(ix, iz, -4);
 							addToClass(ix, iz, clWater);
 						}
 					}
 				}
 
 			}
 		}
 		if ((mdd2 == 2)||(mdd2 == 3))
 		{
 			var distance = randFloat(0., 0.1);
 			for (var ix = 0; ix < mapSize; ix++)
 			{
 				for (var iz = 0; iz < mapSize; iz++)
 				{
 					if (iz < (0.31-distance) * mapSize)
 					{
 						if (iz > (0.31-distance) * mapSize - fadedistance)
 						{
 							setHeight(ix, iz, 3 - 7 * ((0.31-distance) * mapSize - iz) / fadedistance);
 							if (3 - 7 * ((0.31-distance) * mapSize - iz) / fadedistance < 0.5)
 								addToClass(ix, iz, clWater);
 						}
 						else
 						{
 							setHeight(ix, iz, -4);
 							addToClass(ix, iz, clWater);
 						}
 					}
 				}
 			}
 		}
 	}
 	else //vertical
 	{
 		if ((mdd2 == 1)||(mdd2 == 3))
 		{
 			var distance = randFloat(0., 0.1);
 			for (var ix = 0; ix < mapSize; ix++)
 			{
 				for (var iz = 0; iz < mapSize; iz++)
 				{
 					if (ix > (0.69+distance) * mapSize)
 					{
 						if (ix < (0.69+distance) * mapSize + fadedistance)
 						{
 							setHeight(ix, iz, 3 - 7 * (ix - (0.69+distance) * mapSize) / fadedistance);
 							if (3 - 7 * (ix - (0.69+distance) * mapSize) / fadedistance < 0.5)
 								addToClass(ix, iz, clWater);
 						}
 						else
 						{
 							setHeight(ix, iz, -4);
 							addToClass(ix, iz, clWater);
 						}
 					}
 				}
 			}
 		}
 		if ((mdd2 == 2)||(mdd2 == 3))
 		{
 			var distance = randFloat(0., 0.1);
 			for (var ix = 0; ix < mapSize; ix++)
 			{
 				for (var iz = 0; iz < mapSize; iz++)
 				{
 					if (ix < (0.31-distance) * mapSize)
 					{
 						if (ix > (0.31-distance) * mapSize - fadedistance)
 						{
 							setHeight(ix, iz, 3 - 7 * ((0.31-distance) * mapSize - ix) / fadedistance);
 							if (3 - 7 * ((0.31-distance) * mapSize - ix) / fadedistance < 0.5)
 								addToClass(ix, iz, clWater);
 						}
 						else
 						{
 							setHeight(ix, iz, -4);
 							addToClass(ix, iz, clWater);
 						}
 					}
 				}
 			}
 		}
 	}
 
 	// create shore jaggedness
 	log("Creating shore jaggedness...");
 	placer = new ChainPlacer(2, floor(scaleByMapSize(4, 6)), 3, 1);
 	terrainPainter = new LayeredPainter(
 		[tCliff, tHill],		// terrains
 		[2]								// widths
 	);
 	elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -5, 4);
 	createAreas(
 		placer,
 		[terrainPainter, elevationPainter, paintClass(clWater)],
 		[avoidClasses(clPlayer, 20), borderClasses(clWater, 6, 4)],
 		scaleByMapSize(7, 130) * 2, 150
 	);
 
 	placer = new ChainPlacer(2, floor(scaleByMapSize(4, 6)), 3, 1);
 	terrainPainter = new LayeredPainter(
 		[tCliff, tHill],		// terrains
 		[2]								// widths
 	);
 	elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 4);
 	createAreas(
 		placer,
 		[terrainPainter, elevationPainter, unPaintClass(clWater)],
 		borderClasses(clWater, 4, 7),
 		scaleByMapSize(12, 130) * 2, 150
 	);
 
 	var mdd3 = randInt(1,5);
 	if (mdd3 == 1)
 	{
 		// create islands
 		log("Creating islands...");
 		placer = new ChainPlacer(floor(scaleByMapSize(4, 7)), floor(scaleByMapSize(7, 10)), floor(scaleByMapSize(16, 40)), 0.07);
 		terrainPainter = new LayeredPainter(
 			[tMainTerrain, tMainTerrain],		// terrains
 			[2]								// widths
 		);
 		elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3.1, 4);
 		createAreas(
 			placer,
 			[terrainPainter, elevationPainter, paintClass(clLand)],
 			avoidClasses(clLand, 3, clPlayer, 3),
 			scaleByMapSize(2, 5)*randInt(8,14)
 		);
 	}
 	else if (mdd3 == 2)
 	{
 		// create extentions
 		log("Creating extentions...");
 		placer = new ChainPlacer(floor(scaleByMapSize(4, 7)), floor(scaleByMapSize(7, 10)), floor(scaleByMapSize(16, 40)), 0.07);
 		terrainPainter = new LayeredPainter(
 			[tMainTerrain, tMainTerrain],		// terrains
 			[2]								// widths
 		);
 		elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3.1, 4);
 		createAreas(
 			placer,
 			[terrainPainter, elevationPainter, paintClass(clLand)],
 			null,
 			scaleByMapSize(2, 5)*randInt(8,14)
 		);
 	}
 }
 //********************************************************************************************************
 else if (md == 7) //gulf
 {
 
 	for (var ix = 0; ix < mapSize; ix++)
 	{
 		for (var iz = 0; iz < mapSize; iz++)
 		{
 			var x = ix / (mapSize + 1.0);
 			var z = iz / (mapSize + 1.0);
 				setHeight(ix, iz, 3);
 		}
 	}
 
 	var mdd1 = randFloat(0,4);
 
 	// randomize player order
 	var playerIDs = [];
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerIDs.push(i+1);
 	}
 	playerIDs = sortPlayers(playerIDs);
 
 	// place players
 
 	var playerX = new Array(numPlayers);
 	var playerZ = new Array(numPlayers);
 	var playerAngle = new Array(numPlayers);
 
 	var startAngle = -PI/6 + (mdd1-1)*PI/2;
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerAngle[i] = startAngle + i*TWO_PI/(numPlayers-1)*2/3;
 		playerX[i] = 0.5 + 0.35*cos(playerAngle[i]);
 		playerZ[i] = 0.5 + 0.35*sin(playerAngle[i]);
 	}
 
 	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 = scaleByMapSize(17,29)/3;
 		placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 		createArea(placer, paintClass(clPlayer), null);
 	}
 
 	fx = fractionToTiles(0.5);
 	fz = fractionToTiles(0.5);
 	ix = round(fx);
 	iz = round(fz);
 
 	var lSize = 1;
 
 	var placer = new ChainPlacer(2, floor(scaleByMapSize(5, 16)), floor(scaleByMapSize(35, 200)), 1, ix, iz, 0, [floor(mapSize * 0.17 * lSize)]);
 	var terrainPainter = new LayeredPainter(
 		[tMainTerrain, tMainTerrain, tMainTerrain, tMainTerrain],		// terrains
 		[1, 4, 2]		// widths
 	);
 
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		-3,				// elevation
 		4				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer,floor(scaleByMapSize(15,25))));
 
 	fx = fractionToTiles(0.5 - 0.2*cos(mdd1*PI/2));
 	fz = fractionToTiles(0.5 - 0.2*sin(mdd1*PI/2));
 	ix = round(fx);
 	iz = round(fz);
 
 	var lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 6))));
 
 	var placer = new ChainPlacer(2, floor(scaleByMapSize(5, 16)), floor(scaleByMapSize(35, 120)), 1, ix, iz, 0, [floor(mapSize * 0.18 * lSize)]);
 	var terrainPainter = new LayeredPainter(
 		[tMainTerrain, tMainTerrain, tMainTerrain, tMainTerrain],		// terrains
 		[1, 4, 2]		// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		-3,				// elevation
 		4				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer,floor(scaleByMapSize(15,25))));
 
 	fx = fractionToTiles(0.5 - 0.49*cos(mdd1*PI/2));
 	fz = fractionToTiles(0.5 - 0.49*sin(mdd1*PI/2));
 	ix = round(fx);
 	iz = round(fz);
 
 	var lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 6))));
 
 	var placer = new ChainPlacer(2, floor(scaleByMapSize(5, 16)), floor(scaleByMapSize(35, 100)), 1, ix, iz, 0, [floor(mapSize * 0.19 * lSize)]);
 	var terrainPainter = new LayeredPainter(
 		[tMainTerrain, tMainTerrain, tMainTerrain, tMainTerrain],		// terrains
 		[1, 4, 2]		// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		-3,				// elevation
 		4				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer,floor(scaleByMapSize(15,25))));
 }
 //********************************************************************************************************
 else if (md == 8) //lakes
 {
 
 	// randomize player order
 	var playerIDs = [];
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerIDs.push(i+1);
 	}
 	playerIDs = sortPlayers(playerIDs);
 
 	// place players
 
 	var playerX = new Array(numPlayers);
 	var playerZ = new Array(numPlayers);
 	var playerAngle = new Array(numPlayers);
 
 	var startAngle = randFloat(0, TWO_PI);
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerAngle[i] = startAngle + i*TWO_PI/numPlayers;
 		playerX[i] = 0.5 + 0.35*cos(playerAngle[i]);
 		playerZ[i] = 0.5 + 0.35*sin(playerAngle[i]);
 	}
 
 	for (var ix = 0; ix < mapSize; ix++)
 	{
 		for (var iz = 0; iz < mapSize; iz++)
 		{
 			var x = ix / (mapSize + 1.0);
 			var z = iz / (mapSize + 1.0);
 				setHeight(ix, iz, 3);
 		}
 	}
 
 	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 = scaleByMapSize(17,29)/3;
 		placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 		createArea(placer, paintClass(clPlayer), null);
 	}
 
 	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 chosenPoint;
 	var lakeAreaLen;
 
 	// create lakes
 	log("Creating lakes...");
 
 	var numLakes = scaleByMapSize(5, 16);
 	for (var i = 0; i < numLakes; ++i)
 	{
 		lakeAreaLen = lakeAreas.length;
 		if (!lakeAreaLen)
 			break;
 
 		chosenPoint = lakeAreas[randInt(lakeAreaLen)];
 
 		placer = new ChainPlacer(1, floor(scaleByMapSize(4, 8)), floor(scaleByMapSize(40, 180)), 0.7, chosenPoint[0], chosenPoint[1]);
 		terrainPainter = new LayeredPainter(
 			[tShore, tWater, tWater],		// terrains
 			[1, 3]								// widths
 		);
 		elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -5, 5);
 		var newLake = createAreas(
 			placer,
 			[terrainPainter, elevationPainter, 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;
 		}
 	}
 }
 //********************************************************************************************************
 else if (md == 9) //passes
 {
 
 	// randomize player order
 	var playerIDs = [];
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerIDs.push(i+1);
 	}
 	playerIDs = sortPlayers(playerIDs);
 
 	// place players
 
 	var playerX = new Array(numPlayers);
 	var playerZ = new Array(numPlayers);
 	var playerAngle = new Array(numPlayers);
 
 	var startAngle = randFloat(0, TWO_PI);
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerAngle[i] = startAngle + i*TWO_PI/numPlayers;
 		playerX[i] = 0.5 + 0.35*cos(playerAngle[i]);
 		playerZ[i] = 0.5 + 0.35*sin(playerAngle[i]);
 	}
 
 	for (var ix = 0; ix < mapSize; ix++)
 	{
 		for (var iz = 0; iz < mapSize; iz++)
 		{
 			var x = ix / (mapSize + 1.0);
 			var z = iz / (mapSize + 1.0);
 				setHeight(ix, iz, 3);
 		}
 	}
 
 	//create ranges
 	log ("Creating ranges...");
 	for (var m = 0; m < numPlayers; m++)
 	{
 		var tang = startAngle + (m+0.5)*TWO_PI/(numPlayers);
 		var placer = new PathPlacer(fractionToTiles(0.5), fractionToTiles(0.5), fractionToTiles(0.5 + 0.49*cos(tang)), fractionToTiles(0.5 + 0.49*sin(tang)), scaleByMapSize(14,24), 0.4, 3*(scaleByMapSize(1,3)), 0.2, 0.05);
 		var terrainPainter = new LayeredPainter(
 			[tShore, tWater, tWater],		// terrains
 			[1, 3]								// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			24,				// elevation
 			3				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 5));
 		placer = new ClumpPlacer(floor(PI*scaleByMapSize(10,50)*scaleByMapSize(10,50)/5), 0.95, 0.6, 10, fractionToTiles(0.5 + 0.49*cos(tang)), fractionToTiles(0.5 + 0.49*sin(tang)));
 		var painter = new LayeredPainter([tWater, tWater], [1]);
 		var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 24, 0);
 		createArea(placer, [painter, elevationPainter], avoidClasses(clPlayer, 5));
 
 		var placer = new PathPlacer(fractionToTiles(0.5 + 0.3*cos(tang) - 0.1 * cos(tang+PI/2)), fractionToTiles(0.5 + 0.3*sin(tang) - 0.1 * sin(tang+PI/2)), fractionToTiles(0.5 + 0.3*cos(tang) + 0.1 * cos(tang+PI/2)), fractionToTiles(0.5 + 0.3*sin(tang) + 0.1 * sin(tang+PI/2)), scaleByMapSize(14,24), 0.4, 3*(scaleByMapSize(1,3)), 0.2, 0.05);
 		var painter = new LayeredPainter([tCliff, tCliff], [1]);
 		var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 2);
 		createArea(placer, [painter, elevationPainter], null);
 	}
 	var mdd1 = randInt (1,3);
 	if (mdd1 <= 2)
 	{
 		var fx = fractionToTiles(0.5);
 		var fz = fractionToTiles(0.5);
 		ix = round(fx);
 		iz = round(fz);
 
 		var placer = new ClumpPlacer(mapArea * 0.005, 0.7, 0.1, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tShore, tWater, tWater, tWater],		// terrains
 			[1, 4, 2]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			24,				// elevation
 			4				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], null);
 	}
 	else
 	{
 		var fx = fractionToTiles(0.5);
 		var fz = fractionToTiles(0.5);
 		ix = round(fx);
 		iz = round(fz);
 
 		var lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 6))));
 
 		var placer = new ClumpPlacer(mapArea * 0.03 * lSize, 0.7, 0.1, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tShore, tWater, tWater, tWater],		// terrains
 			[1, 4, 2]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			-4,				// elevation
 			3				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], null);
 	}
 }
 //********************************************************************************************************
 else if (md == 10) //lowlands
 {
 	// randomize player order
 	var playerIDs = [];
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerIDs.push(i+1);
 	}
 	playerIDs = sortPlayers(playerIDs);
 
 	// place players
 
 	var playerX = new Array(numPlayers);
 	var playerZ = new Array(numPlayers);
 	var playerAngle = new Array(numPlayers);
 
 	var startAngle = randFloat(0, TWO_PI);
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerAngle[i] = startAngle + i*TWO_PI/numPlayers;
 		playerX[i] = 0.5 + 0.35*cos(playerAngle[i]);
 		playerZ[i] = 0.5 + 0.35*sin(playerAngle[i]);
 	}
 
 	for (var ix = 0; ix < mapSize; ix++)
 	{
 		for (var iz = 0; iz < mapSize; iz++)
 		{
 			var x = ix / (mapSize + 1.0);
 			var z = iz / (mapSize + 1.0);
 				setHeight(ix, iz, 30);
 		}
 	}
 
 
 	var radius = scaleByMapSize(18,32);
 	var cliffRadius = 2;
 	var elevation = 20;
 	var hillSize = PI * radius * radius;
 
 	var split = 1;
 	if ((mapSize / 64 == 2)&&(numPlayers <= 2))
 	{
 		split = 2;
 	}
 	else if ((mapSize / 64 == 3)&&(numPlayers <= 3))
 	{
 		split = 2;
 	}
 	else if ((mapSize / 64 == 4)&&(numPlayers <= 4))
 	{
 		split = 2;
 	}
 	else if ((mapSize / 64 == 5)&&(numPlayers <= 4))
 	{
 		split = 2;
 	}
 	else if ((mapSize / 64 == 6)&&(numPlayers <= 5))
 	{
 		split = 2;
 	}
 	else if ((mapSize / 64 == 7)&&(numPlayers <= 6))
 	{
 		split = 2;
 	}
 
 	for (var i = 0; i < numPlayers*split; i++)
 	{
 		var tang = startAngle + (i)*TWO_PI/(numPlayers*split);
 		var fx = fractionToTiles(0.5 + 0.35*cos(tang));
 		var fz = fractionToTiles(0.5 + 0.35*sin(tang));
 		var ix = round(fx);
 		var iz = round(fz);
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.65, 0.1, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tMainTerrain, tMainTerrain],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			3,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 	}
 
 	var fx = fractionToTiles(0.5);
 	var fz = fractionToTiles(0.5);
 	ix = round(fx);
 	iz = round(fz);
 
 	var lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 6))));
 
 	var placer = new ClumpPlacer(mapArea * 0.091 * lSize, 0.7, 0.1, 10, ix, iz);
 	var terrainPainter = new LayeredPainter(
 		[tMainTerrain, tMainTerrain, tMainTerrain, tMainTerrain],		// terrains
 		[1, 4, 2]		// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		3,				// elevation
 		4				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], null);
 
 	for (var m = 0; m < numPlayers*split; m++)
 	{
 		var tang = startAngle + m*TWO_PI/(numPlayers*split);
 		var placer = new PathPlacer(fractionToTiles(0.5), fractionToTiles(0.5), fractionToTiles(0.5 + 0.35*cos(tang)), fractionToTiles(0.5 + 0.35*sin(tang)), scaleByMapSize(14,24), 0.4, 3*(scaleByMapSize(1,3)), 0.2, 0.05);
 		var terrainPainter = new LayeredPainter(
 			[tMainTerrain, tMainTerrain, tMainTerrain],		// terrains
 			[1, 3]								// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			3,				// elevation
 			4				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], null);
 	}
 }
 //********************************************************************************************************
 else //mainland
 {
 
 	// randomize player order
 	var playerIDs = [];
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerIDs.push(i+1);
 	}
 	playerIDs = sortPlayers(playerIDs);
 
 	// place players
 
 	var playerX = new Array(numPlayers);
 	var playerZ = new Array(numPlayers);
 	var playerAngle = new Array(numPlayers);
 
 	var startAngle = randFloat(0, TWO_PI);
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerAngle[i] = startAngle + i*TWO_PI/numPlayers;
 		playerX[i] = 0.5 + 0.35*cos(playerAngle[i]);
 		playerZ[i] = 0.5 + 0.35*sin(playerAngle[i]);
 	}
 
 	for (var ix = 0; ix < mapSize; ix++)
 	{
 		for (var iz = 0; iz < mapSize; iz++)
 		{
 			var x = ix / (mapSize + 1.0);
 			var z = iz / (mapSize + 1.0);
 				setHeight(ix, iz, 3);
 		}
 	}
 
 }
 
 paintTerrainBasedOnHeight(3.12, 40, 1, tCliff);
 paintTerrainBasedOnHeight(3, 3.12, 1, tMainTerrain);
 paintTerrainBasedOnHeight(1, 3, 1, tShore);
 paintTerrainBasedOnHeight(-8, 1, 2, tWater);
 unPaintTileClassBasedOnHeight(0, 3.12, 1, clWater);
 unPaintTileClassBasedOnHeight(-6, 0, 1, clLand);
 paintTileClassBasedOnHeight(-6, 0, 1, clWater);
 paintTileClassBasedOnHeight(0, 3.12, 1, clLand);
 paintTileClassBasedOnHeight(3.12, 40, 1, clHill);
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	// some constants
 	var radius = scaleByMapSize(17,29);
 	var shoreRadius = 4;
 	var elevation = 3;
 
 	var hillSize = PI * radius * radius;
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 
 	// create starting units
 	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);
 	if (needsAdditionalWood)
 	{
 		// create woods
 		var bbAngle = randFloat(0, TWO_PI);
 		var bbDist = 13;
 		var bbX = round(fx + bbDist * cos(bbAngle));
 		var bbZ = round(fz + bbDist * sin(bbAngle));
 		group = new SimpleGroup(
 			[new SimpleObject(oWood, 14,14, 0,3)],
 			true, clBaseResource, bbX, bbZ
 		);
 		createObjectGroup(group, 0);
 	}
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 	var hillSize = PI * radius * radius;
 	// create starting trees
 	var num = 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);
 }
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 	// create the city patch
 	var cityRadius = radius/3;
 	placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tRoadWild, tRoad], [1]);
 	createArea(placer, [painter, paintClass(clPlayer)], null);
 }
 
 // create bumps
 log("Creating bumps...");
 placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1);
 painter = new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2);
 createAreas(
 	placer,
 	painter,
 	[avoidClasses(clWater, 2, clPlayer, 10), stayClasses(clLand, 3)],
 	randInt(0,scaleByMapSize(200, 400))
 );
 
 // create hills
 log("Creating hills...");
 placer = new ChainPlacer(1, floor(scaleByMapSize(4, 6)), floor(scaleByMapSize(16, 40)), 0.5);
 terrainPainter = new LayeredPainter(
 	[tCliff, tHill],		// terrains
 	[2]								// widths
 );
 elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 18, 2);
 createAreas(
 	placer,
 	[terrainPainter, elevationPainter, paintClass(clHill)],
 	[avoidClasses(clPlayer, 20, clHill, randInt(6, 18)), stayClasses(clLand, 0)],
 	randInt(0, scaleByMapSize(4, 8))*randInt(1, scaleByMapSize(4, 9))
 );
 
 var multiplier = sqrt(randFloat(0.5,1.2)*randFloat(0.5,1.2));
 // calculate desired number of trees for map (based on size)
 if (random_terrain == g_BiomeSavanna)
 {
 	var MIN_TREES = floor(200*multiplier);
 	var MAX_TREES = floor(1250*multiplier);
 	var P_FOREST = 0;
 }
 else if (random_terrain == g_BiomeTropic)
 {
 	var MIN_TREES = floor(1000*multiplier);
 	var MAX_TREES = floor(6000*multiplier);
 	var P_FOREST = randFloat(0.5, 0.7);
 }
 else
 {
 	var MIN_TREES = floor(500*multiplier);
 	var MAX_TREES = floor(3000*multiplier);
 	var P_FOREST = randFloat(0.5,0.8);
 }
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 var numForest = totalTrees * P_FOREST;
 var numStragglers = totalTrees * (1.0 - P_FOREST);
 
 // create forests
 log("Creating forests...");
 var types = [
 	[[tForestFloor2, tMainTerrain, pForest1], [tForestFloor2, pForest1]],
 	[[tForestFloor1, tMainTerrain, pForest2], [tForestFloor1, pForest2]]
 ];	// some variation
 
 if (random_terrain != g_BiomeSavanna)
 {
 	var size = numForest / (scaleByMapSize(3,6) * numPlayers);
 	var num = floor(size / types.length);
 	for (var i = 0; i < types.length; ++i)
 	{
 		placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), numForest / num, 0.5);
 		painter = new LayeredPainter(
 			types[i],		// terrains
 			[2]											// widths
 			);
 		createAreas(
 			placer,
 			[painter, paintClass(clForest)],
 			[avoidClasses(clPlayer, 20, clForest, randInt(5, 15), clHill, 0), stayClasses(clLand, 4)],
 			num
 		);
 	}
 }
 
 RMS.SetProgress(50);
 // create dirt patches
 log("Creating dirt patches...");
 var sizes = [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)];
 var numb = 1;
 if (random_terrain == 6)
 	numb = 3;
 for (var i = 0; i < sizes.length; i++)
 {
 	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
 	painter = new LayeredPainter(
 		[[tMainTerrain,tTier1Terrain],[tTier1Terrain,tTier2Terrain], [tTier2Terrain,tTier3Terrain]], 		// terrains
 		[1,1]															// widths
 	);
 	createAreas(
 		placer,
 		[painter, paintClass(clDirt)],
 		[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 7), stayClasses(clLand, 4)],
 		numb*scaleByMapSize(15, 45)
 	);
 }
 
 // create grass patches
 log("Creating grass patches...");
 var sizes = [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)];
 for (var i = 0; i < sizes.length; i++)
 {
 	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
 	painter = new TerrainPainter(tTier4Terrain);
 	createAreas(
 		placer,
 		painter,
 		[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 7), stayClasses(clLand, 4)],
 		numb*scaleByMapSize(15, 45)
 	);
 }
 RMS.SetProgress(55);
 
 
 log("Creating stone mines...");
 // create large stone quarries
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
 createObjectGroups(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 20, clRock, 10, clHill, 1), stayClasses(clLand, 4)],
 	randInt(scaleByMapSize(2,9),scaleByMapSize(9,40)), 100
 );
 
 // create small stone quarries
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroups(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 20, clRock, 10, clHill, 1), stayClasses(clLand, 4)],
 	randInt(scaleByMapSize(2,9),scaleByMapSize(9,40)), 100
 );
 
 log("Creating metal mines...");
 // create large metal quarries
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroups(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 1), stayClasses(clLand, 4)],
 	randInt(scaleByMapSize(2,9),scaleByMapSize(9,40)), 100
 );
 
 RMS.SetProgress(65);
 
 // create small decorative rocks
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockMedium, 1,3, 0,1)],
 	true
 );
 createObjectGroups(
 	group, 0,
 	[avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 4)],
 	scaleByMapSize(16, 262), 50
 );
 
 
 // create large decorative rocks
 log("Creating large decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
 	true
 );
 createObjectGroups(
 	group, 0,
 	[avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 4)],
 	scaleByMapSize(8, 131), 50
 );
 
 RMS.SetProgress(70);
 
 // create deer
 log("Creating deer...");
 group = new SimpleGroup(
 	[new SimpleObject(oMainHuntableAnimal, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clWater, 0, clForest, 0, clPlayer, 20, clHill, 1, clFood, 20), stayClasses(clLand, 4)],
 	randInt(numPlayers+3, 5*numPlayers+4), 50
 );
 
 // create berry bush
 log("Creating berry bush...");
 group = new SimpleGroup(
 	[new SimpleObject(oFruitBush, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clWater, 0, clForest, 0, clPlayer, 20, clHill, 1, clFood, 20), stayClasses(clLand, 4)],
 	randInt(1, 4) * numPlayers + 2, 50
 );
 
 RMS.SetProgress(75);
 
 // create sheep
 log("Creating sheep...");
 group = new SimpleGroup(
 	[new SimpleObject(oSecondaryHuntableAnimal, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clWater, 0, clForest, 0, clPlayer, 20, clHill, 1, clFood, 20), stayClasses(clLand, 4)],
 	randInt(numPlayers+3, 5*numPlayers+4), 50
 );
 
 // create fish
 log("Creating fish...");
 group = new SimpleGroup(
 	[new SimpleObject(oFish, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroups(group, 0,
 	avoidClasses(clLand, 5, clForest, 0, clPlayer, 0, clHill, 0, clFood, 20),
 	randInt(15, 40) * numPlayers, 60
 );
 
 RMS.SetProgress(85);
 
 
 // create straggler trees
 log("Creating straggler trees...");
 var types = [oTree1, oTree2, oTree4, oTree3];	// some variation
 var num = floor(numStragglers / types.length);
 for (var i = 0; i < types.length; ++i)
 {
 	group = new SimpleGroup(
 		[new SimpleObject(types[i], 1,1, 0,3)],
 		true, clForest
 	);
 	createObjectGroups(group, 0,
 		[avoidClasses(clWater, 1, clForest, 7, clHill, 1, clPlayer, 0, clMetal, 6, clRock, 6), stayClasses(clLand, 4)],
 		num
 	);
 }
 
 var planetm = 1;
 if (random_terrain == g_BiomeTropic)
 	planetm = 8;
 
 //create small grass tufts
 log("Creating small grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)]
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clWater, 2, clHill, 2, clPlayer, 2, clDirt, 0), stayClasses(clLand, 4)],
 	planetm * scaleByMapSize(13, 200)
 );
 
 RMS.SetProgress(90);
 
 // create large grass tufts
 log("Creating large grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aGrass, 2,4, 0,1.8, -PI/8,PI/8), new SimpleObject(aGrassShort, 3,6, 1.2,2.5, -PI/8,PI/8)]
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clWater, 3, clHill, 2, clPlayer, 2, clDirt, 1, clForest, 0), stayClasses(clLand, 4)],
 	planetm * scaleByMapSize(13, 200)
 );
 
 RMS.SetProgress(95);
 
 // create shallow flora
 log("Creating shallow flora...");
 group = new SimpleGroup(
 	[new SimpleObject(aLillies, 1,2, 0,2), new SimpleObject(aReeds, 2,4, 0,2)]
 );
 createObjectGroups(group, 0,
 	stayClasses(clShallow, 1),
 	60 * scaleByMapSize(13, 200), 80
 );
 
 // create bushes
 log("Creating bushes...");
 group = new SimpleGroup(
 	[new SimpleObject(aBushMedium, 1,2, 0,2), new SimpleObject(aBushSmall, 2,4, 0,2)]
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clWater, 1, clHill, 1, clPlayer, 1, clDirt, 1), stayClasses(clLand, 3)],
 	planetm * scaleByMapSize(13, 200), 50
 );
 
-random_terrain = randInt(1,6);
-if (random_terrain == 1)
-	setSkySet("cirrus");
-else if (random_terrain == 2)
-	setSkySet("cumulus");
-else if (random_terrain == 3)
-	setSkySet("sunny");
-else if (random_terrain == 4)
-	setSkySet("sunny 1");
-else if (random_terrain == 5)
-	setSkySet("mountainous");
-else if (random_terrain == 6)
-	setSkySet("stratus");
-
+setSkySet(pickRandom(["cirrus", "cumulus", "sunny", "sunny 1", "mountainous", "stratus"]));
 setSunRotation(randFloat(0, TWO_PI));
 setSunElevation(randFloat(PI/ 5, PI / 3));
 
 // Export map data
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/unknown_nomad.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/unknown_nomad.js	(revision 19285)
+++ ps/trunk/binaries/data/mods/public/maps/random/unknown_nomad.js	(revision 19286)
@@ -1,1684 +1,1671 @@
 RMS.LoadLibrary("rmgen");
 
 TILE_CENTERED_HEIGHT_MAP = true;
 //random terrain textures
 var rt = randomizeBiome();
 
 var tGrass = rBiomeT1();
 var tGrassPForest = rBiomeT2();
 var tGrassDForest = rBiomeT3();
 var tCliff = rBiomeT4();
 var tGrassA = rBiomeT5();
 var tGrassB = rBiomeT6();
 var tGrassC = rBiomeT7();
 var tHill = rBiomeT8();
 var tDirt = rBiomeT9();
 var tRoad = rBiomeT10();
 var tRoadWild = rBiomeT11();
 var tGrassPatch = rBiomeT12();
 var tShoreBlend = rBiomeT13();
 var tShore = rBiomeT14();
 var tWater = rBiomeT15();
 
 // gaia entities
 var oOak = rBiomeE1();
 var oOakLarge = rBiomeE2();
 var oApple = rBiomeE3();
 var oPine = rBiomeE4();
 var oAleppoPine = rBiomeE5();
 var oBerryBush = rBiomeE6();
 var oDeer = rBiomeE8();
 var oFish = rBiomeE9();
 var oSheep = rBiomeE10();
 var oStoneLarge = rBiomeE11();
 var oStoneSmall = rBiomeE12();
 var oMetalLarge = rBiomeE13();
 var oWood = "gaia/special_treasure_wood";
 
 // decorative props
 var aGrass = rBiomeA1();
 var aGrassShort = rBiomeA2();
 var aReeds = rBiomeA3();
 var aLillies = rBiomeA4();
 var aRockLarge = rBiomeA5();
 var aRockMedium = rBiomeA6();
 var aBushMedium = rBiomeA7();
 var aBushSmall = rBiomeA8();
 
 var pForestD = [tGrassDForest + TERRAIN_SEPARATOR + oOak, tGrassDForest + TERRAIN_SEPARATOR + oOakLarge, tGrassDForest];
 var pForestP = [tGrassPForest + TERRAIN_SEPARATOR + oPine, tGrassPForest + TERRAIN_SEPARATOR + oAleppoPine, tGrassPForest];
 
 log("Initializing map...");
 
 InitMap();
 
 var numPlayers = getNumPlayers();
 var mapSize = getMapSize();
 var mapArea = mapSize*mapSize;
 
 // create tile classes
 
 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 clSettlement = createTileClass();
 var clLand = createTileClass();
 var clShallow = createTileClass();
 
 for (var ix = 0; ix < mapSize; ix++)
 {
 	for (var iz = 0; iz < mapSize; iz++)
 	{
 		var x = ix / (mapSize + 1.0);
 		var z = iz / (mapSize + 1.0);
 			placeTerrain(ix, iz, tWater);
 	}
 }
 
 var startAngle = randFloat(0, TWO_PI);
 var md = randInt(1,13);
 var needsAdditionalWood = false;
 //*****************************************************************************************************************************
 if (md == 1) //archipelago and island
 {
 	needsAdditionalWood = true;
 
 	// randomize player order
 	var playerIDs = [];
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerIDs.push(i+1);
 	}
 	playerIDs = sortPlayers(playerIDs);
 
 	var radius = scaleByMapSize(17, 29);
 	var hillSize = PI * radius * radius;
 
 	var mdd1 = randInt(1,3);
 
 	if (mdd1 == 1) //archipelago
 	{
 		// create islands
 		log("Creating islands...");
 		placer = new ClumpPlacer(floor(hillSize*randFloat(0.8,1.2)), 0.80, 0.1, 10);
 		terrainPainter = new LayeredPainter(
 			[tGrass, tGrass],		// terrains
 			[2]								// widths
 		);
 		elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 4);
 		createAreas(
 			placer,
 			[terrainPainter, elevationPainter, paintClass(clLand)],
 			null,
 			scaleByMapSize(2, 5)*randInt(8,14)
 		);
 	}
 	else if (mdd1 == 2) //islands
 	{
 		// create islands
 		log("Creating islands...");
 		placer = new ClumpPlacer(floor(hillSize*randFloat(0.6,1.4)), 0.80, 0.1, randFloat(0.0, 0.2));
 		terrainPainter = new LayeredPainter(
 			[tGrass, tGrass],		// terrains
 			[2]								// widths
 		);
 		elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 4);
 		createAreas(
 			placer,
 			[terrainPainter, elevationPainter, paintClass(clLand)],
 			avoidClasses(clLand, 3, clPlayer, 3),
 			scaleByMapSize(6, 10)*randInt(8,14)
 		);
 	}
 	else if (mdd1 == 3) // tight islands
 	{
 		// create islands
 		log("Creating islands...");
 		placer = new ClumpPlacer(floor(hillSize*randFloat(0.8,1.2)), 0.80, 0.1, 10);
 		terrainPainter = new LayeredPainter(
 			[tGrass, tGrass],		// terrains
 			[2]								// widths
 		);
 		elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 4);
 		createAreas(
 			placer,
 			[terrainPainter, elevationPainter, paintClass(clLand)],
 			avoidClasses(clLand, randInt(8, 16), clPlayer, 3),
 			scaleByMapSize(2, 5)*randInt(8,14)
 		);
 	}
 
 }
 //********************************************************************************************************
 else if (md == 2) //continent
 {
 
 	// randomize player order
 	var playerIDs = [];
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerIDs.push(i+1);
 	}
 	playerIDs = sortPlayers(playerIDs);
 
 	var fx = fractionToTiles(0.5);
 	var fz = fractionToTiles(0.5);
 	ix = round(fx);
 	iz = round(fz);
 
 	var placer = new ClumpPlacer(mapArea * 0.45, 0.9, 0.09, 10, ix, iz);
 	var terrainPainter = new LayeredPainter(
 		[tWater, tShore, tGrass],		// terrains
 		[4, 2]		// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		3,				// elevation
 		4				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 	if (randInt(1,4)==1) // peninsula
 	{
 		var angle = randFloat(0, TWO_PI);
 
 		var fx = fractionToTiles(0.5 + 0.25*cos(angle));
 		var fz = fractionToTiles(0.5 + 0.25*sin(angle));
 		ix = round(fx);
 		iz = round(fz);
 
 		var placer = new ClumpPlacer(mapArea * 0.45, 0.9, 0.09, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tWater, tShore, tGrass],		// terrains
 			[4, 2]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			3,				// elevation
 			4				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 	}
 
 	var mdd1 = randInt(1,3);
 	if (mdd1 == 1)
 	{
 		// create islands
 		log("Creating islands...");
 		placer = new ClumpPlacer(randInt(scaleByMapSize(8,15),scaleByMapSize(15,23))*randInt(scaleByMapSize(8,15),scaleByMapSize(15,23)), 0.80, 0.1, randFloat(0.0, 0.2));
 		terrainPainter = new LayeredPainter(
 			[tGrass, tGrass],		// terrains
 			[2]								// widths
 		);
 		elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 4);
 		createAreas(
 			placer,
 			[terrainPainter, elevationPainter, paintClass(clLand)],
 			avoidClasses(clLand, 3, clPlayer, 3),
 			scaleByMapSize(2, 5)*randInt(8,14)
 		);
 	}
 	else if (mdd1 == 2)
 	{
 		// create extentions
 		log("Creating extentions...");
 		placer = new ClumpPlacer(randInt(scaleByMapSize(13,24),scaleByMapSize(24,45))*randInt(scaleByMapSize(13,24),scaleByMapSize(24,45)), 0.80, 0.1, 10);
 		terrainPainter = new LayeredPainter(
 			[tGrass, tGrass],		// terrains
 			[2]								// widths
 		);
 		elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 4);
 		createAreas(
 			placer,
 			[terrainPainter, elevationPainter, paintClass(clLand)],
 			null,
 			scaleByMapSize(2, 5)*randInt(8,14)
 		);
 	}
 }
 //********************************************************************************************************
 else if (md == 3) //central sea
 {
 	// randomize player order
 	var playerIDs = [];
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerIDs.push(i+1);
 	}
 	playerIDs = primeSortPlayers(sortPlayers(playerIDs));
 
 	var WATER_WIDTH = randFloat(0.22,0.3)+scaleByMapSize(1,4)/20;
 	log("Creating sea");
 	var theta = randFloat(0, 1);
 	var theta2 = randFloat(0, 1);
 	var seed = randFloat(2,3);
 	var seed2 = randFloat(2,3);
 	for (var ix = 0; ix < mapSize; ix++)
 	{
 		for (var iz = 0; iz < mapSize; iz++)
 		{
 			var x = ix / (mapSize + 1.0);
 			var z = iz / (mapSize + 1.0);
 
 			// add the rough shape of the water
 			var km = 20/scaleByMapSize(35, 160);
 
 			var fadeDist = 0.05;
 
 			if (mdd1 == 1) //vertical
 			{
 				var cu = km*rndRiver(theta+z*0.5*(mapSize/64),seed);
 				var cu2 = km*rndRiver(theta2+z*0.5*(mapSize/64),seed2);
 
 				if ((x > cu + 0.5 - WATER_WIDTH/2) && (x < cu + 0.5 + WATER_WIDTH/2))
 				{
 					var h;
 					if (x < (cu + 0.5 + fadeDist - WATER_WIDTH/2))
 					{
 						h = 3 - 6 * (1 - ((cu + 0.5 + fadeDist - WATER_WIDTH/2) - x)/fadeDist);
 					}
 					else if (x > (cu2 + 0.5 - fadeDist + WATER_WIDTH/2))
 					{
 						h = 3 - 6 * (1 - (x - (cu2 + 0.5 - fadeDist + WATER_WIDTH/2))/fadeDist);
 					}
 					else
 					{
 						h = -3.0;
 					}
 
 					if (h < -1.5)
 					{
 						placeTerrain(ix, iz, tWater);
 					}
 					else
 					{
 						placeTerrain(ix, iz, tShore);
 					}
 
 					setHeight(ix, iz, h);
 					if (h < 0){
 						addToClass(ix, iz, clWater);
 					}
 				}
 				else
 				{
 					setHeight(ix, iz, 3.1);
 					addToClass(ix, iz, clLand);
 				}
 			}
 			else //horizontal
 			{
 				var cu = km*rndRiver(theta+x*0.5*(mapSize/64),seed);
 				var cu2 = km*rndRiver(theta2+x*0.5*(mapSize/64),seed2);
 
 				if ((z > cu + 0.5 - WATER_WIDTH/2) && (z < cu + 0.5 + WATER_WIDTH/2))
 				{
 					var h;
 					if (z < (cu + 0.5 + fadeDist - WATER_WIDTH/2))
 					{
 						h = 3 - 6 * (1 - ((cu + 0.5 + fadeDist - WATER_WIDTH/2) - z)/fadeDist);
 					}
 					else if (z > (cu2 + 0.5 - fadeDist + WATER_WIDTH/2))
 					{
 						h = 3 - 6 * (1 - (z - (cu2 + 0.5 - fadeDist + WATER_WIDTH/2))/fadeDist);
 					}
 					else
 					{
 						h = -3.0;
 					}
 
 					if (h < -1.5)
 					{
 						placeTerrain(ix, iz, tWater);
 					}
 					else
 					{
 						placeTerrain(ix, iz, tShore);
 					}
 
 					setHeight(ix, iz, h);
 					if (h < 0){
 						addToClass(ix, iz, clWater);
 					}
 				}
 				else
 				{
 					setHeight(ix, iz, 3.1);
 					addToClass(ix, iz, clLand);
 				}
 			}
 		}
 	}
 
 	if (!randInt(3))
 	{
 		if (mdd1 == 1) //vertical
 		{
 			var placer = new PathPlacer(1, fractionToTiles(0.5), fractionToTiles(0.99), fractionToTiles(0.5), scaleByMapSize(randInt(16,24),randInt(100,140)), 0.5, 3*(scaleByMapSize(1,4)), 0.1, 0.01);
 		}
 		else
 		{
 			var placer = new PathPlacer(fractionToTiles(0.5), 1, fractionToTiles(0.5), fractionToTiles(0.99), scaleByMapSize(randInt(16,24),randInt(100,140)), 0.5, 3*(scaleByMapSize(1,4)), 0.1, 0.01);
 		}
 		var terrainPainter = new LayeredPainter(
 			[tGrass, tGrass, tGrass],		// terrains
 			[1, 3]								// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			3.1,				// elevation
 			4				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, unPaintClass(clWater)], null);
 	}
 	var mdd2 = randInt(1,3);
 	if (mdd2 == 1)
 	{
 		// create islands
 		log("Creating islands...");
 		placer = new ClumpPlacer(randInt(scaleByMapSize(8,15),scaleByMapSize(15,23))*randInt(scaleByMapSize(8,15),scaleByMapSize(15,23)), 0.80, 0.1, randFloat(0.0, 0.2));
 		terrainPainter = new LayeredPainter(
 			[tGrass, tGrass],		// terrains
 			[2]								// widths
 		);
 		elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3.1, 4);
 		createAreas(
 			placer,
 			[terrainPainter, elevationPainter, paintClass(clLand)],
 			avoidClasses(clLand, 3, clPlayer, 3),
 			scaleByMapSize(2, 5)*randInt(8,14)
 		);
 	}
 	else if (mdd2 == 2)
 	{
 		// create extentions
 		log("Creating extentions...");
 		placer = new ClumpPlacer(randInt(scaleByMapSize(13,24),scaleByMapSize(24,45))*randInt(scaleByMapSize(13,24),scaleByMapSize(24,45)), 0.80, 0.1, 10);
 		terrainPainter = new LayeredPainter(
 			[tGrass, tGrass],		// terrains
 			[2]								// widths
 		);
 		elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3.1, 4);
 		createAreas(
 			placer,
 			[terrainPainter, elevationPainter, paintClass(clLand)],
 			null,
 			scaleByMapSize(2, 5)*randInt(8,14)
 		);
 	}
 }
 //********************************************************************************************************
 else if (md == 4) //central river
 {
 
 	for (var ix = 0; ix < mapSize; ix++)
 	{
 		for (var iz = 0; iz < mapSize; iz++)
 		{
 			var x = ix / (mapSize + 1.0);
 			var z = iz / (mapSize + 1.0);
 				setHeight(ix, iz, 3);
 		}
 	}
 
 	// randomize player order
 	var playerIDs = [];
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerIDs.push(i+1);
 	}
 	playerIDs = primeSortPlayers(sortPlayers(playerIDs));
 
 	// create the main river
 	log("Creating the main river");
 
 	if (mdd1 == 2)
 		var placer = new PathPlacer(fractionToTiles(0.5), 1, fractionToTiles(0.5) , fractionToTiles(0.99), scaleByMapSize(14,24), 0.5, 3*(scaleByMapSize(1,4)), 0.1, 0.01);
 	else
 		var placer = new PathPlacer(1, fractionToTiles(0.5), fractionToTiles(0.99), fractionToTiles(0.5), scaleByMapSize(14,24), 0.5, 3*(scaleByMapSize(1,4)), 0.1, 0.01);
 
 	var terrainPainter = new LayeredPainter(
 		[tShore, tWater, tWater],		// terrains
 		[1, 3]								// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		-4,				// elevation
 		4				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter], avoidClasses(clPlayer, 4));
 
 	if (mdd1 == 1)
 		placer = new ClumpPlacer(floor(PI*scaleByMapSize(10,20)*scaleByMapSize(10,20)/4), 0.95, 0.6, 10, 1, fractionToTiles(0.5));
 	else
 		placer = new ClumpPlacer(floor(PI*scaleByMapSize(10,20)*scaleByMapSize(10,20)/4), 0.95, 0.6, 10, fractionToTiles(0.5), 1);
 
 	var painter = new LayeredPainter([tWater, tWater], [1]);
 	var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -4, 2);
 	createArea(placer, [painter, elevationPainter], avoidClasses(clPlayer, 8));
 
 	if (mdd1 == 1)
 		placer = new ClumpPlacer(floor(PI*scaleByMapSize(10,20)*scaleByMapSize(10,20)/4), 0.95, 0.6, 10, fractionToTiles(0.99), fractionToTiles(0.5));
 	else
 		placer = new ClumpPlacer(floor(PI*scaleByMapSize(10,20)*scaleByMapSize(10,20)/4), 0.95, 0.6, 10, fractionToTiles(0.5), fractionToTiles(0.99));
 
 	var painter = new LayeredPainter([tWater, tWater], [1]);
 	var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -4, 2);
 	createArea(placer, [painter, elevationPainter], avoidClasses(clPlayer, 8));
 
 	var mdd2 = randInt(1,2);
 	if (mdd2 == 1)
 	{
 		// create the shallows of the main river
 		log("Creating the shallows of the main river");
 
 		for (var i = 0; i <= randInt(1, scaleByMapSize(4,8)); i++)
 		{
 			var cLocation = randFloat(0.15,0.85);
 			if (mdd1 == 1)
 				passageMaker(fractionToTiles(cLocation), fractionToTiles(0.35), fractionToTiles(cLocation), fractionToTiles(0.65), scaleByMapSize(4,8), -2, -2, 2, clShallow, undefined, -4);
 			else
 				passageMaker(fractionToTiles(0.35), fractionToTiles(cLocation), fractionToTiles(0.65), fractionToTiles(cLocation), scaleByMapSize(4,8), -2, -2, 2, clShallow, undefined, -4);
 		}
 	}
 
 	if (randInt(1,2) == 1)
 	{
 
 		// create tributaries
 		log("Creating tributaries");
 
 		for (var i = 0; i <= randInt(8, (scaleByMapSize(12,20))); i++)
 		{
 			var cLocation = randFloat(0.05,0.95);
 			var tang = randFloat(PI*0.2, PI*0.8)*((randInt(2)-0.5)*2);
 			if (tang > 0)
 			{
 				var cDistance = 0.05;
 			}
 			else
 			{
 				var cDistance = -0.05;
 			}
 			if (mdd1 == 1)
 				var point = getTIPIADBON([fractionToTiles(cLocation), fractionToTiles(0.5 + cDistance)], [fractionToTiles(cLocation), fractionToTiles(0.5 - cDistance)], [-6, -1.5], 0.5, 4, 0.01);
 			else
 				var point = getTIPIADBON([fractionToTiles(0.5 + cDistance), fractionToTiles(cLocation)], [fractionToTiles(0.5 - cDistance), fractionToTiles(cLocation)], [-6, -1.5], 0.5, 4, 0.01);
 
 			if (point !== undefined)
 			{
 				if (mdd1 == 1)
 					var placer = new PathPlacer(floor(point[0]), floor(point[1]), floor(fractionToTiles(0.5 + 0.49*cos(tang))), floor(fractionToTiles(0.5 + 0.49*sin(tang))), scaleByMapSize(10,20), 0.4, 3*(scaleByMapSize(1,4)), 0.1, 0.05);
 				else
 					var placer = new PathPlacer(floor(point[0]), floor(point[1]), floor(fractionToTiles(0.5 + 0.49*sin(tang))), floor(fractionToTiles(0.5 + 0.49*cos(tang))), scaleByMapSize(10,20), 0.4, 3*(scaleByMapSize(1,4)), 0.1, 0.05);
 
 
 				var terrainPainter = new LayeredPainter(
 					[tShore, tWater, tWater],		// terrains
 					[1, 3]								// widths
 				);
 				var elevationPainter = new SmoothElevationPainter(
 					ELEVATION_SET,			// type
 					-4,				// elevation
 					4				// blend radius
 				);
 				var success = createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 2, clWater, 3, clShallow, 2));
 				if (success !== undefined)
 				{
 					if (mdd1 == 1)
 						placer = new ClumpPlacer(floor(PI*scaleByMapSize(10,20)*scaleByMapSize(10,20)/4), 0.95, 0.6, 10, fractionToTiles(0.5 + 0.49*cos(tang)), fractionToTiles(0.5 + 0.49*sin(tang)));
 					else
 						placer = new ClumpPlacer(0.95, floor(PI*scaleByMapSize(10,20)*scaleByMapSize(10,20)/4), 0.6, 10, fractionToTiles(0.5 + 0.49*cos(tang)), fractionToTiles(0.5 + 0.49*sin(tang)));
 
 					var painter = new LayeredPainter([tWater, tWater], [1]);
 					var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -4, 2);
 					createArea(placer, [painter, elevationPainter], avoidClasses(clPlayer, 15));
 				}
 			}
 		}
 	}
 }
 //********************************************************************************************************
 else if (md == 5) //rivers and lake
 {
 
 	// randomize player order
 	var playerIDs = [];
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerIDs.push(i+1);
 	}
 	playerIDs = sortPlayers(playerIDs);
 
 	for (var ix = 0; ix < mapSize; ix++)
 	{
 		for (var iz = 0; iz < mapSize; iz++)
 		{
 			var x = ix / (mapSize + 1.0);
 			var z = iz / (mapSize + 1.0);
 				setHeight(ix, iz, 3);
 		}
 	}
 
 	var mdd1 = randInt(1,3);
 
 	if (mdd1 < 3) //lake
 	{
 		var fx = fractionToTiles(0.5);
 		var fz = fractionToTiles(0.5);
 		ix = round(fx);
 		iz = round(fz);
 
 		var lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 6))));
 
 		var placer = new ClumpPlacer(mapArea * 0.09 * lSize, 0.7, 0.1, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tShore, tWater, tWater, tWater],		// terrains
 			[1, 4, 2]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			-4,				// elevation
 			4				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], null);
 	}
 
 	if (mdd1 > 1) //rivers
 	{
 		//create rivers
 		log ("Creating rivers...");
 		for (var m = 0; m < numPlayers; m++)
 		{
 			var tang = startAngle + (m+0.5)*TWO_PI/(numPlayers);
 			var placer = new PathPlacer(fractionToTiles(0.5), fractionToTiles(0.5), fractionToTiles(0.5 + 0.49*cos(tang)), fractionToTiles(0.5 + 0.49*sin(tang)), scaleByMapSize(14,24), 0.4, 3*(scaleByMapSize(1,3)), 0.2, 0.05);
 			var terrainPainter = new LayeredPainter(
 				[tShore, tWater, tWater],		// terrains
 				[1, 3]								// widths
 			);
 			var elevationPainter = new SmoothElevationPainter(
 				ELEVATION_SET,			// type
 				-4,				// elevation
 				4				// blend radius
 			);
 			createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 5));
 			placer = new ClumpPlacer(floor(PI*scaleByMapSize(10,50)*scaleByMapSize(10,50)/5), 0.95, 0.6, 10, fractionToTiles(0.5 + 0.49*cos(tang)), fractionToTiles(0.5 + 0.49*sin(tang)));
 			var painter = new LayeredPainter([tWater, tWater], [1]);
 			var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -4, 0);
 			createArea(placer, [painter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 5));
 
 		}
 
 		var fx = fractionToTiles(0.5);
 		var fz = fractionToTiles(0.5);
 		ix = round(fx);
 		iz = round(fz);
 
 		var placer = new ClumpPlacer(mapArea * 0.005, 0.7, 0.1, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tShore, tWater, tWater, tWater],		// terrains
 			[1, 4, 2]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			-4,				// elevation
 			4				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], null);
 	}
 
 	if (randInt(1,3) == 1 && mdd1 < 3)//island
 	{
 		var placer = new ClumpPlacer(mapArea * 0.006 * lSize, 0.7, 0.1, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tShore, tWater, tWater, tWater],		// terrains
 			[1, 4, 2]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			3,				// elevation
 			4				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], null);
 	}
 }
 //********************************************************************************************************
 else if (md == 6) //edge seas
 {
 
 	for (var ix = 0; ix < mapSize; ix++)
 	{
 		for (var iz = 0; iz < mapSize; iz++)
 		{
 			var x = ix / (mapSize + 1.0);
 			var z = iz / (mapSize + 1.0);
 				setHeight(ix, iz, 3);
 		}
 	}
 
 	var mdd1 = randInt(1,2);
 
 	// randomize player order
 	var playerIDs = [];
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerIDs.push(i+1);
 	}
 	playerIDs = sortPlayers(playerIDs);
 
 	var mdd2 = randInt(1,3);
 	var fadedistance = 7;
 
 	if (mdd1 == 1)
 	{
 		if ((mdd2 == 1)||(mdd2 == 3))
 		{
 			var distance = randFloat(0., 0.1);
 			for (var ix = 0; ix < mapSize; ix++)
 			{
 				for (var iz = 0; iz < mapSize; iz++)
 				{
 					if (iz > (0.69+distance) * mapSize)
 					{
 						if (iz < (0.69+distance) * mapSize + fadedistance)
 						{
 							setHeight(ix, iz, 3 - 7 * (iz - (0.69+distance) * mapSize) / fadedistance);
 							if (3 - 7 * (iz - (0.69+distance) * mapSize) / fadedistance < 0.5)
 								addToClass(ix, iz, clWater);
 						}
 						else
 						{
 							setHeight(ix, iz, -4);
 							addToClass(ix, iz, clWater);
 						}
 					}
 				}
 
 			}
 
 			for (var i = 0; i < scaleByMapSize(20,120); i++)
 			{
 				placer = new ClumpPlacer(scaleByMapSize(50, 70), 0.2, 0.1, 10, randFloat(0.1,0.9)*mapSize, randFloat(0.67+distance,0.74+distance)*mapSize);
 				var terrainPainter = new LayeredPainter(
 					[tGrass, tGrass],		// terrains
 					[2]								// widths
 				);
 				var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 3);
 				createArea(
 					placer,
 					[terrainPainter, elevationPainter, unPaintClass(clWater)],
 					null
 				);
 			}
 		}
 		if ((mdd2 == 2)||(mdd2 == 3))
 		{
 			var distance = randFloat(0., 0.1);
 			for (var ix = 0; ix < mapSize; ix++)
 			{
 				for (var iz = 0; iz < mapSize; iz++)
 				{
 					if (iz < (0.31-distance) * mapSize)
 					{
 						if (iz > (0.31-distance) * mapSize - fadedistance)
 						{
 							setHeight(ix, iz, 3 - 7 * ((0.31-distance) * mapSize - iz) / fadedistance);
 							if (3 - 7 * ((0.31-distance) * mapSize - iz) / fadedistance < 0.5)
 								addToClass(ix, iz, clWater);
 						}
 						else
 						{
 							setHeight(ix, iz, -4);
 							addToClass(ix, iz, clWater);
 						}
 					}
 				}
 			}
 
 			for (var i = 0; i < scaleByMapSize(20,120); i++)
 			{
 				placer = new ClumpPlacer(scaleByMapSize(50, 70), 0.2, 0.1, 10, randFloat(0.1,0.9)*mapSize, randFloat(0.26-distance,0.34-distance)*mapSize);
 				var terrainPainter = new LayeredPainter(
 					[tGrass, tGrass],		// terrains
 					[2]								// widths
 				);
 				var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 3);
 				createArea(
 					placer,
 					[terrainPainter, elevationPainter, unPaintClass(clWater)],
 					null
 				);
 			}
 		}
 	}
 	else //vertical
 	{
 		if ((mdd2 == 1)||(mdd2 == 3))
 		{
 			var distance = randFloat(0., 0.1);
 			for (var ix = 0; ix < mapSize; ix++)
 			{
 				for (var iz = 0; iz < mapSize; iz++)
 				{
 					if (ix > (0.69+distance) * mapSize)
 					{
 						if (ix < (0.69+distance) * mapSize + fadedistance)
 						{
 							setHeight(ix, iz, 3 - 7 * (ix - (0.69+distance) * mapSize) / fadedistance);
 							if (3 - 7 * (ix - (0.69+distance) * mapSize) / fadedistance < 0.5)
 								addToClass(ix, iz, clWater);
 						}
 						else
 						{
 							setHeight(ix, iz, -4);
 							addToClass(ix, iz, clWater);
 						}
 					}
 				}
 			}
 
 			for (var i = 0; i < scaleByMapSize(20,120); i++)
 			{
 				placer = new ClumpPlacer(scaleByMapSize(50, 70), 0.2, 0.1, 10, randFloat(0.67+distance,0.74+distance)*mapSize, randFloat(0.1,0.9)*mapSize);
 				var terrainPainter = new LayeredPainter(
 					[tGrass, tGrass],		// terrains
 					[2]								// widths
 				);
 				var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 3);
 				createArea(
 					placer,
 					[terrainPainter, elevationPainter, unPaintClass(clWater)],
 					null
 				);
 			}
 		}
 		if ((mdd2 == 2)||(mdd2 == 3))
 		{
 			var distance = randFloat(0., 0.1);
 			for (var ix = 0; ix < mapSize; ix++)
 			{
 				for (var iz = 0; iz < mapSize; iz++)
 				{
 					if (ix < (0.31-distance) * mapSize)
 					{
 						if (ix > (0.31-distance) * mapSize - fadedistance)
 						{
 							setHeight(ix, iz, 3 - 7 * ((0.31-distance) * mapSize - ix) / fadedistance);
 							if (3 - 7 * ((0.31-distance) * mapSize - ix) / fadedistance < 0.5)
 								addToClass(ix, iz, clWater);
 						}
 						else
 						{
 							setHeight(ix, iz, -4);
 							addToClass(ix, iz, clWater);
 						}
 					}
 				}
 			}
 
 			for (var i = 0; i < scaleByMapSize(20,120); i++)
 			{
 				placer = new ClumpPlacer(scaleByMapSize(50, 70), 0.2, 0.1, 10, randFloat(0.26-distance,0.34-distance)*mapSize, randFloat(0.1,0.9)*mapSize);
 				var terrainPainter = new LayeredPainter(
 					[tGrass, tGrass],		// terrains
 					[2]								// widths
 				);
 				var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 3);
 				createArea(
 					placer,
 					[terrainPainter, elevationPainter, unPaintClass(clWater)],
 					null
 				);
 			}
 		}
 	}
 
 	var mdd3 = randInt(1,3);
 	if (mdd3 == 1)
 	{
 		// create islands
 		log("Creating islands...");
 		placer = new ClumpPlacer(randInt(scaleByMapSize(8,15),scaleByMapSize(15,23))*randInt(scaleByMapSize(8,15),scaleByMapSize(15,23)), 0.80, 0.1, randFloat(0.0, 0.2));
 		terrainPainter = new LayeredPainter(
 			[tGrass, tGrass],		// terrains
 			[2]								// widths
 		);
 		elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3.1, 4);
 		createAreas(
 			placer,
 			[terrainPainter, elevationPainter, paintClass(clLand)],
 			avoidClasses(clLand, 3, clPlayer, 3),
 			scaleByMapSize(2, 5)*randInt(8,14)
 		);
 	}
 	else if (mdd3 == 2)
 	{
 		// create extentions
 		log("Creating extentions...");
 		placer = new ClumpPlacer(randInt(scaleByMapSize(13,24),scaleByMapSize(24,45))*randInt(scaleByMapSize(13,24),scaleByMapSize(24,45)), 0.80, 0.1, 10);
 		terrainPainter = new LayeredPainter(
 			[tGrass, tGrass],		// terrains
 			[2]								// widths
 		);
 		elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3.1, 4);
 		createAreas(
 			placer,
 			[terrainPainter, elevationPainter, paintClass(clLand)],
 			null,
 			scaleByMapSize(2, 5)*randInt(8,14)
 		);
 	}
 }
 //********************************************************************************************************
 else if (md == 7) //gulf
 {
 
 	for (var ix = 0; ix < mapSize; ix++)
 	{
 		for (var iz = 0; iz < mapSize; iz++)
 		{
 			var x = ix / (mapSize + 1.0);
 			var z = iz / (mapSize + 1.0);
 				setHeight(ix, iz, 3);
 		}
 	}
 
 	var mdd1 = randInt(1,4);
 
 	// randomize player order
 	var playerIDs = [];
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerIDs.push(i+1);
 	}
 	playerIDs = sortPlayers(playerIDs);
 
 	var fx = fractionToTiles(0.5);
 	var fz = fractionToTiles(0.5);
 	ix = round(fx);
 	iz = round(fz);
 
 	var lSize = 1;
 
 	var placer = new ClumpPlacer(mapArea * 0.08 * lSize, 0.7, 0.05, 10, ix, iz);
 	var terrainPainter = new LayeredPainter(
 		[tGrass, tGrass, tGrass, tGrass],		// terrains
 		[1, 4, 2]		// widths
 	);
 
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		-3,				// elevation
 		4				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer,scaleByMapSize(15,25)));
 
 	var fx = fractionToTiles(0.5 - 0.2*cos(mdd1*PI/2));
 	var fz = fractionToTiles(0.5 - 0.2*sin(mdd1*PI/2));
 	ix = round(fx);
 	iz = round(fz);
 
 	var lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 6))));
 
 	var placer = new ClumpPlacer(mapArea * 0.13 * lSize, 0.7, 0.05, 10, ix, iz);
 	var terrainPainter = new LayeredPainter(
 		[tGrass, tGrass, tGrass, tGrass],		// terrains
 		[1, 4, 2]		// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		-3,				// elevation
 		4				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer,scaleByMapSize(15,25)));
 
 	var fx = fractionToTiles(0.5 - 0.49*cos(mdd1*PI/2));
 	var fz = fractionToTiles(0.5 - 0.49*sin(mdd1*PI/2));
 	ix = round(fx);
 	iz = round(fz);
 
 	var lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 6))));
 
 	var placer = new ClumpPlacer(mapArea * 0.15 * lSize, 0.7, 0.05, 10, ix, iz);
 	var terrainPainter = new LayeredPainter(
 		[tGrass, tGrass, tGrass, tGrass],		// terrains
 		[1, 4, 2]		// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		-3,				// elevation
 		4				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer,scaleByMapSize(15,25)));
 }
 //********************************************************************************************************
 else if (md == 8) //lakes
 {
 
 	// randomize player order
 	var playerIDs = [];
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerIDs.push(i+1);
 	}
 	playerIDs = sortPlayers(playerIDs);
 
 	for (var ix = 0; ix < mapSize; ix++)
 	{
 		for (var iz = 0; iz < mapSize; iz++)
 		{
 			var x = ix / (mapSize + 1.0);
 			var z = iz / (mapSize + 1.0);
 				setHeight(ix, iz, 3);
 		}
 	}
 
 
 	// create lakes
 	log("Creating lakes...");
 	placer = new ClumpPlacer(scaleByMapSize(160, 700), 0.2, 0.1, 1);
 	terrainPainter = new LayeredPainter(
 		[tShore, tWater, tWater],		// terrains
 		[1, 3]								// widths
 	);
 	elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -5, 5);
 	if (randInt(1,2) == 1)
 	{
 		createAreas(
 			placer,
 			[terrainPainter, elevationPainter, paintClass(clWater)],
 			avoidClasses(clPlayer, 12, clWater, 8),
 			scaleByMapSize(5, 16)
 		);
 	}
 	else
 	{
 		createAreas(
 			placer,
 			[terrainPainter, elevationPainter, paintClass(clWater)],
 			avoidClasses(clPlayer, 12),
 			scaleByMapSize(5, 16)
 		);
 	}
 }
 //********************************************************************************************************
 else if (md == 9) //passes
 {
 
 	// randomize player order
 	var playerIDs = [];
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerIDs.push(i+1);
 	}
 	playerIDs = sortPlayers(playerIDs);
 
 	for (var ix = 0; ix < mapSize; ix++)
 	{
 		for (var iz = 0; iz < mapSize; iz++)
 		{
 			var x = ix / (mapSize + 1.0);
 			var z = iz / (mapSize + 1.0);
 				setHeight(ix, iz, 3);
 		}
 	}
 
 	//create ranges
 	log ("Creating ranges...");
 	for (var m = 0; m < numPlayers; m++)
 	{
 		var tang = startAngle + (m+0.5)*TWO_PI/(numPlayers);
 		var placer = new PathPlacer(fractionToTiles(0.5), fractionToTiles(0.5), fractionToTiles(0.5 + 0.49*cos(tang)), fractionToTiles(0.5 + 0.49*sin(tang)), scaleByMapSize(14,24), 0.4, 3*(scaleByMapSize(1,3)), 0.2, 0.05);
 		var terrainPainter = new LayeredPainter(
 			[tShore, tWater, tWater],		// terrains
 			[1, 3]								// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			24,				// elevation
 			3				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 5));
 		placer = new ClumpPlacer(floor(PI*scaleByMapSize(10,50)*scaleByMapSize(10,50)/5), 0.95, 0.6, 10, fractionToTiles(0.5 + 0.49*cos(tang)), fractionToTiles(0.5 + 0.49*sin(tang)));
 		var painter = new LayeredPainter([tWater, tWater], [1]);
 		var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 24, 0);
 		createArea(placer, [painter, elevationPainter], avoidClasses(clPlayer, 5));
 
 		var placer = new PathPlacer(fractionToTiles(0.5 + 0.3*cos(tang) - 0.1 * cos(tang+PI/2)), fractionToTiles(0.5 + 0.3*sin(tang) - 0.1 * sin(tang+PI/2)), fractionToTiles(0.5 + 0.3*cos(tang) + 0.1 * cos(tang+PI/2)), fractionToTiles(0.5 + 0.3*sin(tang) + 0.1 * sin(tang+PI/2)), scaleByMapSize(14,24), 0.4, 3*(scaleByMapSize(1,3)), 0.2, 0.05);
 		var painter = new LayeredPainter([tCliff, tCliff], [1]);
 		var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 2);
 		createArea(placer, [painter, elevationPainter], null);
 	}
 	var mdd1 = randInt (1,3);
 	if (mdd1 <= 2)
 	{
 		var fx = fractionToTiles(0.5);
 		var fz = fractionToTiles(0.5);
 		ix = round(fx);
 		iz = round(fz);
 
 		var placer = new ClumpPlacer(mapArea * 0.005, 0.7, 0.1, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tShore, tWater, tWater, tWater],		// terrains
 			[1, 4, 2]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			24,				// elevation
 			4				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], null);
 	}
 	else
 	{
 		var fx = fractionToTiles(0.5);
 		var fz = fractionToTiles(0.5);
 		ix = round(fx);
 		iz = round(fz);
 
 		var lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 6))));
 
 		var placer = new ClumpPlacer(mapArea * 0.03 * lSize, 0.7, 0.1, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tShore, tWater, tWater, tWater],		// terrains
 			[1, 4, 2]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			-4,				// elevation
 			3				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], null);
 	}
 }
 //********************************************************************************************************
 else if (md == 10) //lowlands
 {
 	// randomize player order
 	var playerIDs = [];
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerIDs.push(i+1);
 	}
 	playerIDs = sortPlayers(playerIDs);
 
 	for (var ix = 0; ix < mapSize; ix++)
 	{
 		for (var iz = 0; iz < mapSize; iz++)
 		{
 			var x = ix / (mapSize + 1.0);
 			var z = iz / (mapSize + 1.0);
 				setHeight(ix, iz, 30);
 		}
 	}
 
 
 	var radius = scaleByMapSize(18,32);
 	var cliffRadius = 2;
 	var elevation = 20;
 	var hillSize = PI * radius * radius;
 
 	var split = 1;
 	if ((mapSize / 64 == 2)&&(numPlayers <= 2))
 	{
 		split = 2;
 	}
 	else if ((mapSize / 64 == 3)&&(numPlayers <= 3))
 	{
 		split = 2;
 	}
 	else if ((mapSize / 64 == 4)&&(numPlayers <= 4))
 	{
 		split = 2;
 	}
 	else if ((mapSize / 64 == 5)&&(numPlayers <= 4))
 	{
 		split = 2;
 	}
 	else if ((mapSize / 64 == 6)&&(numPlayers <= 5))
 	{
 		split = 2;
 	}
 	else if ((mapSize / 64 == 7)&&(numPlayers <= 6))
 	{
 		split = 2;
 	}
 
 	for (var i = 0; i < numPlayers*split; i++)
 	{
 		var tang = startAngle + (i)*TWO_PI/(numPlayers*split);
 		var fx = fractionToTiles(0.5 + 0.35*cos(tang));
 		var fz = fractionToTiles(0.5 + 0.35*sin(tang));
 		var ix = round(fx);
 		var iz = round(fz);
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.65, 0.1, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tGrass, tGrass],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			3,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 	}
 
 	var fx = fractionToTiles(0.5);
 	var fz = fractionToTiles(0.5);
 	ix = round(fx);
 	iz = round(fz);
 
 	var lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 6))));
 
 	var placer = new ClumpPlacer(mapArea * 0.091 * lSize, 0.7, 0.1, 10, ix, iz);
 	var terrainPainter = new LayeredPainter(
 		[tGrass, tGrass, tGrass, tGrass],		// terrains
 		[1, 4, 2]		// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		3,				// elevation
 		4				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], null);
 
 	for (var m = 0; m < numPlayers*split; m++)
 	{
 		var tang = startAngle + m*TWO_PI/(numPlayers*split);
 		var placer = new PathPlacer(fractionToTiles(0.5), fractionToTiles(0.5), fractionToTiles(0.5 + 0.35*cos(tang)), fractionToTiles(0.5 + 0.35*sin(tang)), scaleByMapSize(14,24), 0.4, 3*(scaleByMapSize(1,3)), 0.2, 0.05);
 		var terrainPainter = new LayeredPainter(
 			[tGrass, tGrass, tGrass],		// terrains
 			[1, 3]								// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			3,				// elevation
 			4				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], null);
 	}
 }
 //********************************************************************************************************
 else //mainland
 {
 
 	// randomize player order
 	var playerIDs = [];
 	for (var i = 0; i < numPlayers; i++)
 	{
 		playerIDs.push(i+1);
 	}
 	playerIDs = sortPlayers(playerIDs);
 
 	for (var ix = 0; ix < mapSize; ix++)
 	{
 		for (var iz = 0; iz < mapSize; iz++)
 		{
 			var x = ix / (mapSize + 1.0);
 			var z = iz / (mapSize + 1.0);
 				setHeight(ix, iz, 3);
 		}
 	}
 
 }
 
 paintTerrainBasedOnHeight(3.12, 40, 1, tCliff);
 paintTerrainBasedOnHeight(3, 3.12, 1, tGrass);
 paintTerrainBasedOnHeight(1, 3, 1, tShore);
 paintTerrainBasedOnHeight(-8, 1, 2, tWater);
 unPaintTileClassBasedOnHeight(0, 3.12, 1, clWater);
 unPaintTileClassBasedOnHeight(-6, 0, 1, clLand);
 paintTileClassBasedOnHeight(-6, 0, 1, clWater);
 paintTileClassBasedOnHeight(0, 3.12, 1, clLand);
 paintTileClassBasedOnHeight(3.12, 40, 1, clHill);
 
 // place players
 
 var playerX = new Array(numPlayers);
 var playerZ = new Array(numPlayers);
 var distmin = scaleByMapSize(60,240);
 distmin *= distmin;
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var placableArea = [];
 	for (var mx = 0; mx < mapSize; mx++)
 	{
 		for (var mz = 0; mz < mapSize; mz++)
 		{
 			if (!g_Map.validT(mx, mz, 6))
 				continue;
 
 			var placable = true;
 			for (var c = 0; c < i; c++)
 				if ((playerX[c] - mx)*(playerX[c] - mx) + (playerZ[c] - mz)*(playerZ[c] - mz) < distmin)
 					placable = false;
 			if (!placable)
 				continue;
 
 			if (g_Map.getHeight(mx, mz) >= 3 && g_Map.getHeight(mx, mz) <= 3.12)
 				placableArea.push([mx, mz]);
 		}
 	}
 
 	if (!placableArea.length)
 	{
 		for (var mx = 0; mx < mapSize; ++mx)
 		{
 			for (var mz = 0; mz < mapSize; mz++)
 			{
 				if (!g_Map.validT(mx, mz, 6))
 					continue;
 
 				var placable = true;
 				for (var c = 0; c < i; c++)
 					if ((playerX[c] - mx)*(playerX[c] - mx) + (playerZ[c] - mz)*(playerZ[c] - mz) < distmin/4)
 						placable = false;
 				if (!placable)
 					continue;
 
 				if (g_Map.getHeight(mx, mz) >= 3 && g_Map.getHeight(mx, mz) <= 3.12)
 					placableArea.push([mx, mz]);
 			}
 		}
 	}
 
 	if (!placableArea.length)
 	{
 		for (var mx = 0; mx < mapSize; ++mx)
 			for (var mz = 0; mz < mapSize; ++mz)
 				if (g_Map.getHeight(mx, mz) >= 3 && g_Map.getHeight(mx, mz) <= 3.12)
 					placableArea.push([mx, mz]);
 	}
 	var chosen = floor(Math.random()*placableArea.length);
 	playerX[i] = placableArea[chosen][0];
 	playerZ[i] = placableArea[chosen][1];
 }
 
 
 for (var i = 0; i < numPlayers; ++i)
 {
 	var id = playerIDs[i];
 	log("Creating units for player " + id + "...");
 
 	// get the x and z in tiles
 	var ix = playerX[i];
 	var iz = playerZ[i];
 	var civEntities = getStartingEntities(id-1);
 	var angle = randFloat(0, TWO_PI);
 	for (var j = 0; j < civEntities.length; ++j)
 	{
 		// TODO: Make an rmlib function to get only non-structure starting entities and loop over those
 		if (!civEntities[j].Template.startsWith("units/"))
 			continue;
 
 		var count = civEntities[j].Count || 1;
 		var jx = ix + 2 * cos(angle);
 		var jz = iz + 2 * sin(angle);
 		var kAngle = randFloat(0, TWO_PI);
 		for (var k = 0; k < count; ++k)
 			placeObject(jx + cos(kAngle + k*TWO_PI/count), jz + sin(kAngle + k*TWO_PI/count), civEntities[j].Template, id, randFloat(0, TWO_PI));
 		angle += TWO_PI / 3;
 	}
 
 	if (md > 9)  // maps without water, so we must have enough resources to build a cc
 	{
 		if (g_MapSettings.StartingResources < 500)
 		{
 			var loop = (g_MapSettings.StartingResources < 200) ? 2 : 1;
 			for (let l = 0; l < loop; ++l)
 			{
 				var angle = randFloat(0, TWO_PI);
 				var rad = randFloat(3, 5);
 				var jx = ix + rad * cos(angle);
 				var jz = iz + rad * sin(angle);
 				placeObject(jx, jz, "gaia/special_treasure_wood", 0, randFloat(0, TWO_PI));
 				var angle = randFloat(0, TWO_PI);
 				var rad = randFloat(3, 5);
 				var jx = ix + rad * cos(angle);
 				var jz = iz + rad * sin(angle);
 				placeObject(jx, jz, "gaia/special_treasure_stone", 0, randFloat(0, TWO_PI));
 				var angle = randFloat(0, TWO_PI);
 				var rad = randFloat(3, 5);
 				var jx = ix + rad * cos(angle);
 				var jz = iz + rad * sin(angle);
 				placeObject(jx, jz, "gaia/special_treasure_metal", 0, randFloat(0, TWO_PI));
 			}
 		}
 	}
 	else    // we must have enough resources to build a dock
 	{
 		if (g_MapSettings.StartingResources < 200)
 		{
 			var angle = randFloat(0, TWO_PI);
 			var rad = randFloat(3, 5);
 			var jx = ix + rad * cos(angle);
 			var jz = iz + rad * sin(angle);
 			placeObject(jx, jz, "gaia/special_treasure_wood", 0, randFloat(0, TWO_PI));
 		}
 	}
 }
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var radius = scaleByMapSize(18,32);
 	var ix = playerX[i];
 	var iz = playerZ[i];
 	var cityRadius = radius/3;
 	placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	createArea(placer, paintClass(clPlayer), null);
 }
 
 // create bumps
 log("Creating bumps...");
 placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1);
 var painter = new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2);
 createAreas(
 	placer,
 	painter,
 	[avoidClasses(clWater, 2, clPlayer, 10), stayClasses(clLand, 3)],
 	randInt(0,scaleByMapSize(200, 400))
 );
 
 // create hills
 log("Creating hills...");
 placer = new ClumpPlacer(scaleByMapSize(20, 150), 0.2, 0.1, 1);
 terrainPainter = new LayeredPainter(
 	[tCliff, tHill],		// terrains
 	[2]								// widths
 );
 elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 18, 2);
 createAreas(
 	placer,
 	[terrainPainter, elevationPainter, paintClass(clHill)],
 	[avoidClasses(clPlayer, 15, clHill, randInt(6, 18)), stayClasses(clLand, 0)],
 	randInt(0, scaleByMapSize(4, 8))*randInt(1, scaleByMapSize(4, 9))
 );
 
 var multiplier = sqrt(randFloat(0.5,1.2)*randFloat(0.5,1.2));
 // calculate desired number of trees for map (based on size)
 if (rt == 6)
 {
 var MIN_TREES = floor(200*multiplier);
 var MAX_TREES = floor(1250*multiplier);
 var P_FOREST = randFloat(0.02, 0.05);
 }
 else if (rt == 7)
 {
 var MIN_TREES = floor(1000*multiplier);
 var MAX_TREES = floor(6000*multiplier);
 var P_FOREST = randFloat(0.5, 0.7);
 }
 else
 {
 var MIN_TREES = floor(500*multiplier);
 var MAX_TREES = floor(3000*multiplier);
 var P_FOREST = randFloat(0.5,0.8);
 }
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 var numForest = totalTrees * P_FOREST;
 var numStragglers = totalTrees * (1.0 - P_FOREST);
 
 // create forests
 log("Creating forests...");
 var types = [
 	[[tGrassDForest, tGrass, pForestD], [tGrassDForest, pForestD]],
 	[[tGrassPForest, tGrass, pForestP], [tGrassPForest, pForestP]]
 ];	// some variation
 
 if (rt == 6)
 {
 var size = numForest / (0.5 * scaleByMapSize(2,8) * numPlayers);
 }
 else
 {
 var size = numForest / (scaleByMapSize(2,8) * numPlayers);
 }
 var num = floor(size / types.length);
 for (var i = 0; i < types.length; ++i)
 {
 	placer = new ClumpPlacer(numForest / num, 0.1, 0.1, 1);
 	painter = new LayeredPainter(
 		types[i],		// terrains
 		[2]											// widths
 		);
 	createAreas(
 		placer,
 		[painter, paintClass(clForest)],
 		[avoidClasses(clPlayer, 17, clForest, randInt(5, 15), clHill, 0), stayClasses(clLand, 4)],
 		num
 	);
 }
 
 RMS.SetProgress(50);
 // create dirt patches
 log("Creating dirt patches...");
 var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
 var numb = 1;
 if (rt == 6)
 	numb = 3;
 for (var i = 0; i < sizes.length; i++)
 {
 	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
 	painter = new LayeredPainter(
 		[[tGrass,tGrassA],[tGrassA,tGrassB], [tGrassB,tGrassC]], 		// terrains
 		[1,1]															// widths
 	);
 	createAreas(
 		placer,
 		[painter, paintClass(clDirt)],
 		[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 0), stayClasses(clLand, 4)],
 		numb*scaleByMapSize(15, 45)
 	);
 }
 
 // create grass patches
 log("Creating grass patches...");
 var sizes = [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)];
 for (var i = 0; i < sizes.length; i++)
 {
 	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
 	painter = new TerrainPainter(tGrassPatch);
 	createAreas(
 		placer,
 		painter,
 		[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 0), stayClasses(clLand, 4)],
 		numb*scaleByMapSize(15, 45)
 	);
 }
 RMS.SetProgress(55);
 
 
 log("Creating stone mines...");
 // create large stone quarries
 var group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
 createObjectGroups(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 10, clRock, 10, clHill, 1), stayClasses(clLand, 3)],
 	randInt(scaleByMapSize(2,9),scaleByMapSize(9,40)), 100
 );
 
 // create small stone quarries
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroups(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 10, clRock, 10, clHill, 1), stayClasses(clLand, 3)],
 	randInt(scaleByMapSize(2,9),scaleByMapSize(9,40)), 100
 );
 
 log("Creating metal mines...");
 // create large metal quarries
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroups(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 10, clMetal, 10, clRock, 5, clHill, 1), stayClasses(clLand, 3)],
 	randInt(scaleByMapSize(2,9),scaleByMapSize(9,40)), 100
 );
 
 RMS.SetProgress(65);
 
 // create small decorative rocks
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockMedium, 1,3, 0,1)],
 	true
 );
 createObjectGroups(
 	group, 0,
 	[avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 3)],
 	scaleByMapSize(16, 262), 50
 );
 
 
 // create large decorative rocks
 log("Creating large decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
 	true
 );
 createObjectGroups(
 	group, 0,
 	[avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 3)],
 	scaleByMapSize(8, 131), 50
 );
 
 RMS.SetProgress(70);
 
 // create deer
 log("Creating deer...");
 group = new SimpleGroup(
 	[new SimpleObject(oDeer, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clWater, 0, clForest, 0, clPlayer, 8, clHill, 1, clFood, 20), stayClasses(clLand, 2)],
 	randInt(numPlayers+3, 5*numPlayers+4), 50
 );
 
 // create berry bush
 log("Creating berry bush...");
 group = new SimpleGroup(
 	[new SimpleObject(oBerryBush, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clWater, 0, clForest, 0, clPlayer, 8, clHill, 1, clFood, 20), stayClasses(clLand, 2)],
 	randInt(1, 4) * numPlayers + 2, 50
 );
 
 RMS.SetProgress(75);
 
 // create sheep
 log("Creating sheep...");
 group = new SimpleGroup(
 	[new SimpleObject(oSheep, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clWater, 0, clForest, 0, clPlayer, 8, clHill, 1, clFood, 20), stayClasses(clLand, 2)],
 	randInt(numPlayers+3, 5*numPlayers+4), 50
 );
 
 // create fish
 log("Creating fish...");
 group = new SimpleGroup(
 	[new SimpleObject(oFish, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroups(group, 0,
 	avoidClasses(clLand, 4, clForest, 0, clPlayer, 0, clHill, 0, clFood, 20),
 	randInt(15, 40) * numPlayers, 60
 );
 
 RMS.SetProgress(85);
 
 
 // create straggler trees
 log("Creating straggler trees...");
 var types = [oOak, oOakLarge, oPine, oApple];	// some variation
 var num = floor(numStragglers / types.length);
 for (var i = 0; i < types.length; ++i)
 {
 	group = new SimpleGroup(
 		[new SimpleObject(types[i], 1,1, 0,3)],
 		true, clForest
 	);
 	createObjectGroups(group, 0,
 		[avoidClasses(clWater, 1, clForest, 1, clHill, 1, clPlayer, 0, clMetal, 6, clRock, 6), stayClasses(clLand, 4)],
 		num
 	);
 }
 
 var planetm = 1;
 if (rt==7)
 {
 	planetm = 8;
 }
 //create small grass tufts
 log("Creating small grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)]
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clWater, 2, clHill, 2, clPlayer, 2, clDirt, 0), stayClasses(clLand, 3)],
 	planetm * scaleByMapSize(13, 200)
 );
 
 RMS.SetProgress(90);
 
 // create large grass tufts
 log("Creating large grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aGrass, 2,4, 0,1.8, -PI/8,PI/8), new SimpleObject(aGrassShort, 3,6, 1.2,2.5, -PI/8,PI/8)]
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clWater, 3, clHill, 2, clPlayer, 2, clDirt, 1, clForest, 0), stayClasses(clLand, 3)],
 	planetm * scaleByMapSize(13, 200)
 );
 
 RMS.SetProgress(95);
 
 // create shallow flora
 log("Creating shallow flora...");
 group = new SimpleGroup(
 	[new SimpleObject(aLillies, 1,2, 0,2), new SimpleObject(aReeds, 2,4, 0,2)]
 );
 createObjectGroups(group, 0,
 	stayClasses(clShallow, 1),
 	60 * scaleByMapSize(13, 200), 80
 );
 
 // create bushes
 log("Creating bushes...");
 group = new SimpleGroup(
 	[new SimpleObject(aBushMedium, 1,2, 0,2), new SimpleObject(aBushSmall, 2,4, 0,2)]
 );
 createObjectGroups(group, 0,
 	[avoidClasses(clWater, 1, clHill, 1, clPlayer, 1, clDirt, 1), stayClasses(clLand, 3)],
 	planetm * scaleByMapSize(13, 200), 50
 );
 
-rt = randInt(1,6);
-if (rt == 1)
-	setSkySet("cirrus");
-else if (rt == 2)
-	setSkySet("cumulus");
-else if (rt == 3)
-	setSkySet("sunny");
-else if (rt == 4)
-	setSkySet("sunny 1");
-else if (rt == 5)
-	setSkySet("mountainous");
-else if (rt == 6)
-	setSkySet("stratus");
-
+setSkySet(pickRandom(["cirrus", "cumulus", "sunny", "sunny 1", "mountainous", "stratus"]));
 setSunRotation(randFloat(0, TWO_PI));
 setSunElevation(randFloat(PI/ 5, PI / 3));
 
 // Export map data
 ExportMap();