Index: ps/trunk/binaries/data/mods/public/maps/random/african_plains.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/african_plains.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/african_plains.js	(revision 20149)
@@ -1,343 +1,330 @@
 RMS.LoadLibrary("rmgen");
 
 var tPrimary = ["savanna_grass_a"];
 var tForestFloor = "savanna_forestfloor_a";
 var tCliff = ["savanna_cliff_a", "savanna_cliff_a_red", "savanna_cliff_b", "savanna_cliff_b_red"];
 var tSecondary = "savanna_grass_b";
 var tGrassShrubs = ["savanna_shrubs_a"];
 var tGrass = ["savanna_grass_a_wetseason", "savanna_grass_b_wetseason"];
 var tDirt = "savanna_dirt_a";
 var tDirt2 = "savanna_dirt_a_red";
 var tDirt3 = "savanna_dirt_b";
 var tDirt4 = "savanna_dirt_rocks_a";
 var tCitytiles = "savanna_tile_a";
 var tShore = "savanna_riparian_bank";
 var tWater = "savanna_riparian_wet";
 
 var oBaobab = "gaia/flora_tree_baobab";
 var oPalm = "gaia/flora_tree_senegal_date_palm";
 var oBerryBush = "gaia/flora_bush_berry";
 var oWildebeest = "gaia/fauna_wildebeest";
 var oZebra = "gaia/fauna_zebra";
 var oRhino = "gaia/fauna_rhino";
 var oLion = "gaia/fauna_lion";
 var oLioness = "gaia/fauna_lioness";
 var oHawk = "gaia/fauna_hawk";
 var oGiraffe = "gaia/fauna_giraffe";
 var oGiraffe2 = "gaia/fauna_giraffe_infant";
 var oGazelle = "gaia/fauna_gazelle";
 var oElephant = "gaia/fauna_elephant_african_bush";
 var oElephant2 = "gaia/fauna_elephant_african_infant";
 var oCrocodile = "gaia/fauna_crocodile";
 var oFish = "gaia/fauna_fish";
 var oStoneSmall = "gaia/geology_stone_savanna_small";
 var oMetalLarge = "gaia/geology_metal_savanna_slabs";
 
 var aBush = "actor|props/flora/bush_medit_sm_dry.xml";
 var aRock = "actor|geology/stone_savanna_med.xml";
 
 const pForest = [tForestFloor + TERRAIN_SEPARATOR + oPalm, tForestFloor];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 RMS.SetProgress(20);
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 
 initTerrain(tPrimary);
 
-var playerIDs = sortAllPlayers();
-
-// 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]);
-}
+var [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; ++i)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 	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([tPrimary,tCitytiles], [1]);
 	createArea(placer, painter, null);
 
 	placeCivDefaultEntities(fx, fz, id);
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oBerryBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while (abs(mAngle - bbAngle) < PI/3)
 		mAngle = randFloat(0, TWO_PI);
 
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	createStoneMineFormation(mX, mZ, tDirt4);
 	addToClass(mX, mZ, clPlayer);
 
 	// create starting trees
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(11, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oBaobab, 2,7)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 }
 RMS.SetProgress(20);
 
 createHills([tDirt2, tCliff, tGrassShrubs], avoidClasses(clPlayer, 35, clForest, 20, clHill, 20, clWater, 2), clHill, scaleByMapSize(5, 8));
 RMS.SetProgress(30);
 
 var lakeAreas = [];
 var playerConstraint = new AvoidTileClassConstraint(clPlayer, 20);
 var waterConstraint = new AvoidTileClassConstraint(clWater, 8);
 
 for (var x = 0; x < mapSize; ++x)
 	for (var z = 0; z < mapSize; ++z)
 		if (playerConstraint.allows(x, z) && waterConstraint.allows(x, z))
 			lakeAreas.push([x, z]);
 
 log("Creating water holes...");
 placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), floor(scaleByMapSize(60, 100)), 5);
 var terrainPainter = new LayeredPainter(
 	[tShore, tWater],		// terrains
 	[1]							// widths
 );
 var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -5, 7);
 createAreas(
 	placer,
 	[terrainPainter, elevationPainter, paintClass(clWater)],
 	avoidClasses(clPlayer, 22, clWater, 8, clHill, 2),
 	scaleByMapSize(2, 5)
 );
 RMS.SetProgress(45);
 
 paintTerrainBasedOnHeight(3, floor(scaleByMapSize(20, 40)), 0, tCliff);
 paintTerrainBasedOnHeight(floor(scaleByMapSize(20, 40)), 100, 3, tGrass);
 
 createBumps(avoidClasses(clWater, 2, clPlayer, 20));
 
 createForests(
 	[tPrimary, tForestFloor, tForestFloor, pForest, pForest],
 	avoidClasses(clPlayer, 20, clForest, 20, clHill, 0, clWater, 2),
 	clForest,
 	1.0
 );
 
 log("Creating dirt patches...");
 createLayeredPatches(
 	[scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
 	[[tDirt,tDirt3], [tDirt2,tDirt4]],
 	[2],
 	avoidClasses(clWater, 3, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12)
 );
 
 log("Creating shrubs...");
 createPatches(
 	[scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
 	tGrassShrubs,
 	avoidClasses(clWater, 3, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12)
 );
 
 log("Creating grass patches...");
 createPatches(
 	[scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
 	tSecondary,
 	avoidClasses(clWater, 3, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12)
 );
 RMS.SetProgress(60);
 
 log("Creating stone mines...");
 createMines(
 	[
 		[new SimpleObject(oStoneSmall, 0,2, 0,4)],
 		[new SimpleObject(oStoneSmall, 2,5, 1,3)]
 	],
 	avoidClasses(clWater, 4, clForest, 4, clPlayer, 20, clRock, 10, clHill, 4)
 );
 
 log("Creating metal mines...");
 createMines(
 	[
 		[new SimpleObject(oMetalLarge, 1,1, 0,4)]
 	],
 	avoidClasses(clWater, 4, clForest, 4, clPlayer, 20, clMetal, 18, clRock, 5, clHill, 4),
 	clMetal
 );
 RMS.SetProgress(70);
 
 createDecoration(
 	[
 		[new SimpleObject(aBush, 1,3, 0,1)],
 		[new SimpleObject(aRock, 1,2, 0,1)]
 	],
 	[
 		scaleByMapSize(8, 131),
 		scaleByMapSize(8, 131),
 	],
 	avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0)
 );
 RMS.SetProgress(75);
 
 log("Creating giraffes...");
 group = new SimpleGroup(
 	[new SimpleObject(oGiraffe, 2,4, 0,4), new SimpleObject(oGiraffe2, 0,2, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clPlayer, 20, clFood, 11, clHill, 4),
 	scaleByMapSize(4,12), 50
 );
 
 log("Creating elephants...");
 group = new SimpleGroup(
 	[new SimpleObject(oElephant, 2,4, 0,4), new SimpleObject(oElephant2, 0,2, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clPlayer, 20, clFood, 11, clHill, 4),
 	scaleByMapSize(4,12), 50
 );
 
 log("Creating lions...");
 group = new SimpleGroup(
 	[new SimpleObject(oLion, 0,1, 0,4), new SimpleObject(oLioness, 2,3, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clPlayer, 20, clFood, 11, clHill, 4),
 	scaleByMapSize(4,12), 50
 );
 
 createFood(
 	[
 		[new SimpleObject(oHawk, 1,1, 0,3)],
 		[new SimpleObject(oGazelle, 3,5, 0,3)],
 		[new SimpleObject(oZebra, 3,5, 0,3)],
 		[new SimpleObject(oWildebeest, 4,6, 0,3)],
 		[new SimpleObject(oRhino, 1,1, 0,3)]
 	],
 	[
 		3 * numPlayers,
 		3 * numPlayers,
 		3 * numPlayers,
 		3 * numPlayers,
 		3 * numPlayers,
 	],
 	avoidClasses(clFood, 20, clWater, 5, clHill, 2, clPlayer, 16)
 );
 
 createFood(
 	[
 		[new SimpleObject(oCrocodile, 2,3, 0,3)]
 	],
 	[
 		3 * numPlayers,
 	],
 	stayClasses(clWater, 6)
 );
 
 createFood(
 	[
 		[new SimpleObject(oBerryBush, 5,7, 0,4)]
 	],
 	[
 		randIntInclusive(1, 4) * numPlayers + 2
 	],
 	avoidClasses(clWater, 3, clForest, 2, clPlayer, 20, clHill, 3, clFood, 10)
 );
 
 createFood(
 	[
 		[new SimpleObject(oFish, 2,3, 0,2)]
 	],
 	[
 		15 * numPlayers
 	],
 	[avoidClasses(clFood, 20), stayClasses(clWater, 6)]
 );
 RMS.SetProgress(85);
 
 createStragglerTrees(
 	[oBaobab],
 	avoidClasses(clWater, 5, clForest, 2, clHill, 3, clPlayer, 12, clMetal, 4, clRock, 4)
 );
 
 setPPEffect("hdr");
 setPPSaturation(0.48);
 setPPContrast(0.53);
 setPPBloom(0.12);
 
 setFogThickness(0.25);
 setFogFactor(0.25);
 setFogColor(0.8, 0.7, 0.5);
 
 setSkySet("sunny");
 setSunRotation(randFloat(0, TWO_PI));
 setSunElevation(randFloat(PI/ 4, PI / 2));
 
 setWaterColor(0.223, 0.247, 0.2); // dark majestic blue
 setWaterTint(0.462, 0.756, 0.566); // light blue
 setWaterMurkiness(5.92);
 setWaterWaviness(0);
 setWaterType("clap");
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/alpine_lakes.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/alpine_lakes.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/alpine_lakes.js	(revision 20149)
@@ -1,375 +1,362 @@
 RMS.LoadLibrary("rmgen");
 
 // late spring
 if (randBool())
 {
 	setFogThickness(0.26);
 	setFogFactor(0.4);
 
 	setPPEffect("hdr");
 	setPPSaturation(0.48);
 	setPPContrast(0.53);
 	setPPBloom(0.12);
 
 	var tPrimary = ["alpine_dirt_grass_50"];
 	var tForestFloor = "alpine_forrestfloor";
 	var tCliff = ["alpine_cliff_a", "alpine_cliff_b", "alpine_cliff_c"];
 	var tSecondary = "alpine_grass_rocky";
 	var tHalfSnow = ["alpine_grass_snow_50", "alpine_dirt_snow"];
 	var tSnowLimited = ["alpine_snow_rocky"];
 	var tDirt = "alpine_dirt";
 	var tRoad = "new_alpine_citytile";
 	var tRoadWild = "new_alpine_citytile";
 	var tShore = "alpine_shore_rocks_grass_50";
 	var tWater = "alpine_shore_rocks";
 
 	// gaia entities
 	var oPine = "gaia/flora_tree_pine";
 	var oBerryBush = "gaia/flora_bush_berry";
 	var oDeer = "gaia/fauna_deer";
 	var oFish = "gaia/fauna_fish";
 	var oRabbit = "gaia/fauna_rabbit";
 	var oStoneLarge = "gaia/geology_stonemine_alpine_quarry";
 	var oStoneSmall = "gaia/geology_stone_alpine_a";
 	var oMetalLarge = "gaia/geology_metal_alpine_slabs";
 
 	// decorative props
 	var aGrass = "actor|props/flora/grass_soft_small_tall.xml";
 	var aGrassShort = "actor|props/flora/grass_soft_large.xml";
 	var aRockLarge = "actor|geology/stone_granite_med.xml";
 	var aRockMedium = "actor|geology/stone_granite_med.xml";
 	var aBushMedium = "actor|props/flora/bush_medit_me.xml";
 	var aBushSmall = "actor|props/flora/bush_medit_sm.xml";
 }
 else
 //winter
 {
 	setFogFactor(0.35);
 	setFogThickness(0.19);
 	setPPSaturation(0.37);
 	setPPEffect("hdr");
 
 	var tPrimary = ["alpine_snow_a", "alpine_snow_b"];
 	var tForestFloor = "alpine_forrestfloor_snow";
 	var tCliff = ["alpine_cliff_snow"];
 	var tSecondary = "alpine_grass_snow_50";
 	var tHalfSnow = ["alpine_grass_snow_50", "alpine_dirt_snow"];
 	var tSnowLimited = ["alpine_snow_a", "alpine_snow_b"];
 	var tDirt = "alpine_dirt";
 	var tRoad = "new_alpine_citytile";
 	var tRoadWild = "new_alpine_citytile";
 	var tShore = "alpine_shore_rocks_icy";
 	var tWater = "alpine_shore_rocks";
 
 	// gaia entities
 	var oPine = "gaia/flora_tree_pine_w";
 	var oBerryBush = "gaia/flora_bush_berry";
 	var oDeer = "gaia/fauna_deer";
 	var oFish = "gaia/fauna_fish";
 	var oRabbit = "gaia/fauna_rabbit";
 	var oStoneLarge = "gaia/geology_stonemine_alpine_quarry";
 	var oStoneSmall = "gaia/geology_stone_alpine_a";
 	var oMetalLarge = "gaia/geology_metal_alpine_slabs";
 
 	// decorative props
 	var aGrass = "actor|props/flora/grass_soft_dry_small_tall.xml";
 	var aGrassShort = "actor|props/flora/grass_soft_dry_large.xml";
 	var aRockLarge = "actor|geology/stone_granite_med.xml";
 	var aRockMedium = "actor|geology/stone_granite_med.xml";
 	var aBushMedium = "actor|props/flora/bush_medit_me_dry.xml";
 	var aBushSmall = "actor|props/flora/bush_medit_sm_dry.xml";
 }
 
 //other constants
 const pForest = [tForestFloor + TERRAIN_SEPARATOR + oPine, tForestFloor];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 const mapArea = mapSize*mapSize;
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clSettlement = createTileClass();
 
 initTerrain(tPrimary);
 
-var playerIDs = sortAllPlayers();
-
-// 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 [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 	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);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oBerryBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 		mAngle = randFloat(0, TWO_PI);
 
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 	var hillSize = PI * radius * radius;
 	// create starting trees
 	var num = floor(hillSize / 100);
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(11, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oPine, num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 
 RMS.SetProgress(20);
 
 log("Creating hills...");
 createMountains(tCliff, avoidClasses(clPlayer, 20, clHill, 8), clHill, scaleByMapSize(10, 40) * numPlayers, floor(scaleByMapSize(40, 60)), floor(scaleByMapSize(4, 5)), floor(scaleByMapSize(7, 15)), floor(scaleByMapSize(5, 15)));
 
 RMS.SetProgress(30);
 
 var lakeAreas = [];
 var playerConstraint = new AvoidTileClassConstraint(clPlayer, 20);
 var waterConstraint = new AvoidTileClassConstraint(clWater, 8);
 
 for (var x = 0; x < mapSize; ++x)
 	for (var z = 0; z < mapSize; ++z)
 		if (playerConstraint.allows(x, z) && waterConstraint.allows(x, z))
 			lakeAreas.push([x, z]);
 
 var lakeAreaLen;
 
 log("Creating lakes...");
 
 var numLakes = scaleByMapSize(5, 16);
 for (var i = 0; i < numLakes; ++i)
 {
 	lakeAreaLen = lakeAreas.length;
 	if (!lakeAreaLen)
 		break;
 
 	let chosenPoint = pickRandom(lakeAreas);
 
 	placer = new ChainPlacer(1, floor(scaleByMapSize(4, 8)), floor(scaleByMapSize(40, 180)), 0.7, chosenPoint[0], chosenPoint[1]);
 	var terrainPainter = new LayeredPainter(
 		[tShore, tWater, tWater],		// terrains
 		[1, 3]								// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -5, 5);
 	var newLake = createAreas(
 		placer,
 		[terrainPainter, elevationPainter, paintClass(clWater)],
 		avoidClasses(clPlayer, 20, clWater, 8),
 		1, 1
 	);
 
 	if (newLake && newLake.length)
 	{
 		var n = 0;
 		for (var j = 0; j < lakeAreaLen; ++j)
 		{
 			var x = lakeAreas[j][0], z = lakeAreas[j][1];
 			if (playerConstraint.allows(x, z) && waterConstraint.allows(x, z))
 				lakeAreas[n++] = lakeAreas[j];
 		}
 		lakeAreas.length = n;
 	}
 
 }
 paintTerrainBasedOnHeight(3, floor(scaleByMapSize(20, 40)), 0, tCliff);
 paintTerrainBasedOnHeight(floor(scaleByMapSize(20, 40)), 100, 3, tSnowLimited);
 
 createBumps(avoidClasses(clWater, 2, clPlayer, 20));
 
 createForests(
  [tPrimary, tForestFloor, tForestFloor, pForest, pForest],
  avoidClasses(clPlayer, 20, clForest, 17, clHill, 0, clWater, 2),
  clForest,
  1.0
 );
 
 RMS.SetProgress(60);
 
 log("Creating dirt patches...");
 createLayeredPatches(
  [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
  [[tDirt,tHalfSnow], [tHalfSnow,tSnowLimited]],
  [2],
  avoidClasses(clWater, 3, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12)
 );
 
 log("Creating grass patches...");
 createPatches(
  [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
  tSecondary,
  avoidClasses(clWater, 3, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12)
 );
 
 RMS.SetProgress(65);
 
 log("Creating stone mines...");
 createMines(
  [
   [new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)],
   [new SimpleObject(oStoneSmall, 2,5, 1,3)]
  ],
  avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clRock, 10, clHill, 1)
 );
 
 log("Creating metal mines...");
 createMines(
  [
   [new SimpleObject(oMetalLarge, 1,1, 0,4)]
  ],
  avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 1),
  clMetal
 );
 
 RMS.SetProgress(70);
 
 createDecoration
 (
  [[new SimpleObject(aRockMedium, 1,3, 0,1)],
   [new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
   [new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)],
   [new SimpleObject(aGrass, 2,4, 0,1.8, -PI/8,PI/8), new SimpleObject(aGrassShort, 3,6, 1.2,2.5, -PI/8,PI/8)],
   [new SimpleObject(aBushMedium, 1,2, 0,2), new SimpleObject(aBushSmall, 2,4, 0,2)]
  ],
  [
   scaleByMapSize(16, 262),
   scaleByMapSize(8, 131),
   scaleByMapSize(13, 200),
   scaleByMapSize(13, 200),
   scaleByMapSize(13, 200)
  ],
  avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0)
 );
 
 RMS.SetProgress(75);
 
 createFood
 (
  [
   [new SimpleObject(oDeer, 5,7, 0,4)],
   [new SimpleObject(oRabbit, 2,3, 0,2)]
  ],
  [
   3 * numPlayers,
   3 * numPlayers
  ],
  avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 20)
 );
 
 createFood
 (
  [
   [new SimpleObject(oBerryBush, 5,7, 0,4)]
  ],
  [
   randIntInclusive(1, 4) * numPlayers + 2
  ],
  avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 10)
 );
 
 createFood
 (
  [
   [new SimpleObject(oFish, 2,3, 0,2)]
  ],
  [
   15 * numPlayers
  ],
  [avoidClasses(clFood, 20), stayClasses(clWater, 6)]
 );
 
 RMS.SetProgress(85);
 
 var types = [oPine];
 createStragglerTrees(types, avoidClasses(clWater, 5, clForest, 3, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6));
 
 setSkySet(pickRandom(["cirrus", "cumulus", "sunny"]));
 setSunRotation(randFloat(0, TWO_PI));
 setSunElevation(randFloat(PI/ 5, PI / 3));
 setWaterColor(0.0, 0.047, 0.286);				// dark majestic blue
 setWaterTint(0.471, 0.776, 0.863);				// light blue
 setWaterMurkiness(0.82);
 setWaterWaviness(3.0);
 setWaterType("clap");
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/alpine_valley.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/alpine_valley.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/alpine_valley.js	(revision 20149)
@@ -1,623 +1,610 @@
 RMS.LoadLibrary("rmgen");
 
 TILE_CENTERED_HEIGHT_MAP = true;
 
 // late spring
 if (randBool())
 {
 	var tPrimary = ["alpine_dirt_grass_50"];
 	var tForestFloor = "alpine_forrestfloor";
 	var tCliff = ["alpine_cliff_a", "alpine_cliff_b", "alpine_cliff_c"];
 	var tSecondary = "alpine_grass_rocky";
 	var tHalfSnow = ["alpine_grass_snow_50", "alpine_dirt_snow"];
 	var tSnowLimited = ["alpine_snow_rocky"];
 	var tDirt = "alpine_dirt";
 	var tRoad = "new_alpine_citytile";
 	var tRoadWild = "new_alpine_citytile";
 	var 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";
 }
 
 const pForest = [tForestFloor + TERRAIN_SEPARATOR + oPine, tForestFloor];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 const mapArea = mapSize*mapSize;
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clSettlement = createTileClass();
 
 initTerrain(tPrimary);
 
-var playerIDs = sortAllPlayers();
-
-// 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]);
-}
+var [playerIDs, playerX, playerZ, playerAngle, startAngle] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	ix = round(fx);
 	iz = round(fz);
 	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 = randIntExclusive(0, possibleEdges.length);
 
 	//ensure that a point is connected to a maximum of 3 others
 	if (edgesConncetedToPoints[possibleEdges[index][0]] > 2 || edgesConncetedToPoints[possibleEdges[index][1]] > 2)
 	{
 		possibleEdges.splice(index,1);
 		continue;
 	}
 
 	//we don't want ranges that are longer than half of the map's size
 	if ((((points[possibleEdges[index][0]][0] - points[possibleEdges[index][1]][0]) *
 		(points[possibleEdges[index][0]][0] - points[possibleEdges[index][1]][0])) +
 		((points[possibleEdges[index][0]][1] - points[possibleEdges[index][1]][1]) *
 		(points[possibleEdges[index][0]][1] - points[possibleEdges[index][1]][1]))) >
 		mapArea)
 	{
 		possibleEdges.splice(index,1);
 		continue;
 	}
 
 	//dfs
 	var q = [possibleEdges[index][0]];
 
 	matrix[possibleEdges[index][0]][possibleEdges[index][1]] = true;
 	matrix[possibleEdges[index][1]][possibleEdges[index][0]] = true;
 	var selected, accept = true, tree = [], backtree = [];
 	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);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 1, clPlayer, 20, clRock, 10, clHill, 1),
 	scaleByMapSize(4,16), 100
 );
 
 log("Creating small stone mines...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 1, clPlayer, 20, clRock, 10, clHill, 1),
 	scaleByMapSize(4,16), 100
 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 1),
 	scaleByMapSize(4,16), 100
 );
 RMS.SetProgress(70);
 
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockMedium, 1,3, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clForest, 0, clPlayer, 0, clHill, 0),
 	scaleByMapSize(16, 262), 50
 );
 
 log("Creating large decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clForest, 0, clPlayer, 0, clHill, 0),
 	scaleByMapSize(8, 131), 50
 );
 RMS.SetProgress(75);
 
 log("Creating deer...");
 group = new SimpleGroup(
 	[new SimpleObject(oDeer, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 10, clHill, 1, clFood, 20),
 	3 * numPlayers, 50
 );
 
 log("Creating berry bush...");
 group = new SimpleGroup(
 	[new SimpleObject(oBerryBush, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 20, clHill, 1, clFood, 10),
 	randIntInclusive(1, 4) * numPlayers + 2, 50
 );
 
 log("Creating rabbit...");
 group = new SimpleGroup(
 	[new SimpleObject(oRabbit, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 10, clHill, 1, clFood, 20),
 	3 * numPlayers, 50
 );
 RMS.SetProgress(85);
 
 log("Creating straggler trees...");
 var types = [oPine, oPine];	// some variation
 var num = floor(numStragglers / types.length);
 for (var i = 0; i < types.length; ++i)
 {
 	group = new SimpleGroup(
 		[new SimpleObject(types[i], 1,1, 0,3)],
 		true, clForest
 	);
 	createObjectGroupsDeprecated(group, 0,
 		avoidClasses(clForest, 1, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6),
 		num
 	);
 }
 
 log("Creating small grass tufts...");
 var planetm = 1;
 
 group = new SimpleGroup(
 	[new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)]
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clHill, 2, clPlayer, 2, clDirt, 0),
 	planetm * scaleByMapSize(13, 200)
 );
 RMS.SetProgress(90);
 
 log("Creating large grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aGrass, 2,4, 0,1.8, -PI/8,PI/8), new SimpleObject(aGrassShort, 3,6, 1.2,2.5, -PI/8,PI/8)]
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clHill, 2, clPlayer, 2, clDirt, 1, clForest, 0),
 	planetm * scaleByMapSize(13, 200)
 );
 RMS.SetProgress(95);
 
 log("Creating bushes...");
 group = new SimpleGroup(
 	[new SimpleObject(aBushMedium, 1,2, 0,2), new SimpleObject(aBushSmall, 2,4, 0,2)]
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clHill, 1, clPlayer, 1, clDirt, 1),
 	planetm * scaleByMapSize(13, 200), 50
 );
 
 setSkySet(pickRandom(["cirrus", "cumulus", "sunny"]));
 setSunRotation(randFloat(0, TWO_PI));
 setSunElevation(randFloat(PI/ 5, PI / 3));
 setWaterColor(0.0, 0.047, 0.286);				// dark majestic blue
 setWaterTint(0.471, 0.776, 0.863);				// light blue
 setWaterMurkiness(0.72);
 setWaterWaviness(2.0);
 setWaterType("lake");
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/anatolian_plateau.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/anatolian_plateau.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/anatolian_plateau.js	(revision 20149)
@@ -1,348 +1,336 @@
 RMS.LoadLibrary("rmgen");
 
 const tGrass = ["steppe_grass_a", "steppe_grass_b", "steppe_grass_c", "steppe_grass_d"];
 const tForestFloor = "steppe_grass_c";
 const tGrassA = "steppe_grass_b";
 const tGrassB = "steppe_grass_c";
 const tGrassC = ["steppe_grass_b", "steppe_grass_c", "steppe_grass_d"];
 const tGrassD = "steppe_grass_a";
 const tDirt = ["steppe_dirt_a", "steppe_dirt_b"];
 const tRoad = "road_stones";
 const tRoadWild = "road_stones";
 const tShoreBlend = "desert_shore_stones";
 const tShore = "dirta";
 const tWater = "desert_sand_wet";
 
 const oPoplar = "gaia/flora_tree_poplar_lombardy";
 const oBush = "gaia/flora_bush_temperate";
 const oBerryBush = "gaia/flora_bush_berry";
 const oRabbit = "gaia/fauna_rabbit";
 const oSheep = "gaia/fauna_sheep";
 const oStoneLarge = "gaia/geology_stonemine_medit_quarry";
 const oStoneSmall = "gaia/geology_stone_mediterranean";
 const oMetalLarge = "gaia/geology_metal_mediterranean_slabs";
 
 const aGrass = "actor|props/flora/grass_soft_small_tall.xml";
 const aGrassShort = "actor|props/flora/grass_soft_large.xml";
 const aRockLarge = "actor|geology/stone_granite_med.xml";
 const aRockMedium = "actor|geology/stone_granite_med.xml";
 const aBushMedium = "actor|props/flora/bush_medit_me.xml";
 const aBushSmall = "actor|props/flora/bush_medit_sm.xml";
 
 const pForest = [tForestFloor + TERRAIN_SEPARATOR + oPoplar, tForestFloor];
 
 InitMap();
 
 var numPlayers = getNumPlayers();
 var mapSize = getMapSize();
 var mapArea = mapSize*mapSize;
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clSettlement = createTileClass();
 
-var playerIDs = sortAllPlayers();
-
-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 [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 	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);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oBerryBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 	var hillSize = PI * radius * radius;
 	// create starting trees
 	var num = floor(hillSize / 100);
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(11, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oPoplar, num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 
 RMS.SetProgress(20);
 
 log("Creating bumps...");
 placer = new ChainPlacer(1, floor(scaleByMapSize(4, 6)), floor(scaleByMapSize(2, 5)), 0.5);
 painter = new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2);
 createAreas(
 	placer,
 	painter,
 	avoidClasses(clPlayer, 13),
 	scaleByMapSize(300, 800)
 );
 
 // calculate desired number of trees for map (based on size)
 
 var MIN_TREES = 220;
 var MAX_TREES = 1000;
 var P_FOREST = 0.65;
 
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 var numForest = totalTrees * P_FOREST;
 var numStragglers = totalTrees * (1.0 - P_FOREST);
 
 log("Creating forests...");
 var types = [[[tForestFloor, tGrass, pForest], [tForestFloor, pForest]]];	// some variation
 
 var size = numForest / (scaleByMapSize(2,8) * numPlayers);
 
 var num = 4 * floor(size / types.length);
 for (var i = 0; i < types.length; ++i)
 {
 	placer = new ChainPlacer(1, floor(scaleByMapSize(2, 3)), 4, 1);
 	painter = new LayeredPainter(
 		types[i],		// terrains
 		[2]											// widths
 		);
 	createAreas(
 		placer,
 		[painter, paintClass(clForest)],
 		avoidClasses(clPlayer, 13, clForest, 20, clHill, 1),
 		num
 	);
 }
 
 RMS.SetProgress(50);
 
 log("Creating grass patches...");
 createLayeredPatches(
  [scaleByMapSize(5, 48), scaleByMapSize(6, 84), scaleByMapSize(8, 128)],
  [[tGrass,tGrassA,tGrassC],[tGrass,tGrassA,tGrassC], [tGrass,tGrassA,tGrassC]],
  [1,1],
  avoidClasses(clForest, 0, clHill, 0, clDirt, 2, clPlayer, 10),
  scaleByMapSize(50, 70),
  clDirt
 );
 
 log("Creating dirt patches...");
 createLayeredPatches(
  [scaleByMapSize(5, 32), scaleByMapSize(6, 48), scaleByMapSize(7, 80)],
  [tGrassD ,tDirt],
  [1],
  avoidClasses(clForest, 0, clHill, 0, clDirt, 2, clPlayer, 10),
  scaleByMapSize(50, 90),
  clDirt
 );
 
 RMS.SetProgress(55);
 
 log("Creating big patches...");
 createLayeredPatches(
  [scaleByMapSize(10, 60), scaleByMapSize(15, 90), scaleByMapSize(20, 120)],
  [tGrassB ,tGrassA],
  [1],
  avoidClasses(clHill, 0, clPlayer, 8),
  scaleByMapSize(30, 90),
  clDirt
 );
 
 RMS.SetProgress(55);
 
 log("Creating stone mines...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 1, clPlayer, 20, clRock, 10, clHill, 1),
 	scaleByMapSize(1,4), 100
 );
 
 log("Creating small stone quarries...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 1, clPlayer, 20, clRock, 10, clHill, 1),
 	scaleByMapSize(1,4), 100
 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 1),
 	scaleByMapSize(2,8), 100
 );
 
 RMS.SetProgress(65);
 
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockMedium, 1,3, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clForest, 0, clPlayer, 10, clHill, 0),
 	scaleByMapSize(16, 262), 50
 );
 
 log("Creating large decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clForest, 0, clPlayer, 10, clHill, 0),
 	scaleByMapSize(8, 131), 50
 );
 
 RMS.SetProgress(70);
 
 log("Creating rabbits...");
 group = new SimpleGroup(
 	[new SimpleObject(oRabbit, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 10, clHill, 1, clFood, 20),
 	6 * numPlayers, 50
 );
 
 log("Creating berry bush...");
 group = new SimpleGroup(
 	[new SimpleObject(oBerryBush, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 20, clHill, 1, clFood, 20),
 	randIntInclusive(1, 4) * numPlayers + 2, 50
 );
 
 RMS.SetProgress(75);
 
 log("Creating sheep...");
 group = new SimpleGroup(
 	[new SimpleObject(oSheep, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 10, clHill, 1, clFood, 20),
 	3 * numPlayers, 50
 );
 
 RMS.SetProgress(85);
 
 log("Creating straggler trees...");
 var types = [oBush, oPoplar];	// some variation
 var num = floor(numStragglers / types.length);
 for (var i = 0; i < types.length; ++i)
 {
 	group = new SimpleGroup(
 		[new SimpleObject(types[i], 1,1, 0,3)],
 		true, clForest
 	);
 	createObjectGroupsDeprecated(group, 0,
 		avoidClasses(clForest, 1, clHill, 1, clPlayer, 13, clMetal, 6, clRock, 6),
 		num
 	);
 }
 
 log("Creating large grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aGrass, 2,4, 0,1.8, -PI/8,PI/8), new SimpleObject(aGrassShort, 3,6, 1.2,2.5, -PI/8,PI/8)]
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clHill, 2, clPlayer, 2, clDirt, 1, clForest, 0),
 	scaleByMapSize(13, 200)
 );
 
 RMS.SetProgress(95);
 
 log("Creating bushes...");
 group = new SimpleGroup(
 	[new SimpleObject(aBushMedium, 1,2, 0,2), new SimpleObject(aBushSmall, 2,4, 0,2)]
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clHill, 1, clPlayer, 1, clDirt, 1),
 	scaleByMapSize(13, 200), 50
 );
 
 setFogThickness(0.1);
 setFogFactor(0.2);
 
 setPPEffect("hdr");
 setPPSaturation(0.45);
 setPPContrast(0.62);
 setPPBloom(0.2);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/archipelago.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/archipelago.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/archipelago.js	(revision 20149)
@@ -1,327 +1,314 @@
 RMS.LoadLibrary("rmgen");
 RMS.LoadLibrary("rmbiome");
 
 TILE_CENTERED_HEIGHT_MAP = true;
 
 setSelectedBiome();
 
 const tMainTerrain = g_Terrains.mainTerrain;
 const tForestFloor1 = g_Terrains.forestFloor1;
 const tForestFloor2 = g_Terrains.forestFloor2;
 const tCliff = g_Terrains.cliff;
 const tTier1Terrain = g_Terrains.tier1Terrain;
 const tTier2Terrain = g_Terrains.tier2Terrain;
 const tTier3Terrain = g_Terrains.tier3Terrain;
 const tHill = g_Terrains.hill;
 const tTier4Terrain = g_Terrains.dirt;
 const tRoad = g_Terrains.road;
 const tRoadWild = g_Terrains.roadWild;
 const tTier5Terrain = g_Terrains.tier4Terrain;
 const tShoreBlend = g_Terrains.shoreBlend;
 const tShore = g_Terrains.shore;
 const tWater = g_Terrains.water;
 
 const oTree1 = g_Gaia.tree1;
 const oTree2 = g_Gaia.tree2;
 const oTree3 = g_Gaia.tree3;
 const oTree4 = g_Gaia.tree4;
 const oTree5 = g_Gaia.tree5;
 const oFruitBush = g_Gaia.fruitBush;
 const oMainHuntableAnimal = g_Gaia.mainHuntableAnimal;
 const oFish = g_Gaia.fish;
 const oSecondaryHuntableAnimal = g_Gaia.secondaryHuntableAnimal;
 const oStoneLarge = g_Gaia.stoneLarge;
 const oStoneSmall = g_Gaia.stoneSmall;
 const oMetalLarge = g_Gaia.metalLarge;
 const oWood = "gaia/special_treasure_wood";
 
 const aGrass = g_Decoratives.grass;
 const aGrassShort = g_Decoratives.grassShort;
 const aReeds = g_Decoratives.reeds;
 const aLillies = g_Decoratives.lillies;
 const aRockLarge = g_Decoratives.rockLarge;
 const aRockMedium = g_Decoratives.rockMedium;
 const aBushMedium = g_Decoratives.bushMedium;
 const aBushSmall = g_Decoratives.bushSmall;
 
 const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
 const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 const mapArea = mapSize*mapSize;
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clSettlement = createTileClass();
 var clLand = createTileClass();
 
-var playerIDs = sortAllPlayers();
-
-// 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 [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(22,31);
 	var shoreRadius = 4;
 	var elevation = 3;
 
 	var hillSize = PI * radius * radius;
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 
 	// create the main island
 	var placer = new ChainPlacer(2, floor(scaleByMapSize(5, 10)), floor(scaleByMapSize(25, 60)), 1, ix, iz, 0, [floor(radius)]);
 	var terrainPainter = new LayeredPainter(
 		[tMainTerrain , tMainTerrain, tMainTerrain],		// terrains
 		[1, shoreRadius]		// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		elevation,				// elevation
 		shoreRadius				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clPlayer)], null);
 
 	placeCivDefaultEntities(fx, fz, id, { 'iberWall': 'towers' });
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oFruitBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create woods
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 13;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oWood, 14,14, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 		mAngle = randFloat(0, TWO_PI);
 
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var num = floor(hillSize / 100);
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(11, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oTree1, num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 
 log("Creating islands...");
 placer = new ChainPlacer(floor(scaleByMapSize(4, 8)), floor(scaleByMapSize(8, 14)), floor(scaleByMapSize(25, 60)), 0.07, undefined, undefined, scaleByMapSize(30,70));
 terrainPainter = new LayeredPainter(
 	[tMainTerrain, tMainTerrain],		// terrains
 	[2]								// widths
 );
 elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 4);
 createAreas(
 	placer,
 	[terrainPainter, elevationPainter, paintClass(clLand)],
 	null,
 	scaleByMapSize(1, 5) * randIntInclusive(5, 10)
 );
 
 paintTerrainBasedOnHeight(2.4, 3.4, 3, tMainTerrain);
 paintTerrainBasedOnHeight(1, 3, 0, tShore);
 paintTerrainBasedOnHeight(-8, 1, 2, tWater);
 
 //creating the city patches for the players
 for (var i = 0; i < numPlayers; i++)
 {
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 	// create the city patch
 	var cityRadius = radius/3;
 	placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tRoadWild, tRoad], [1]);
 	createArea(placer, painter, null);
 }
 
 createBumps([avoidClasses(clPlayer, 10), stayClasses(clLand, 5)]);
 
 if (randBool())
 	createHills([tMainTerrain, tCliff, tHill], [avoidClasses(clPlayer, 2, clHill, 15), stayClasses(clLand, 0)], clHill, scaleByMapSize(1, 4) * numPlayers);
 else
 	createMountains(tCliff, [avoidClasses(clPlayer, 2, clHill, 15), stayClasses(clLand, 0)], clHill, scaleByMapSize(1, 4) * numPlayers);
 
 createForests(
  [tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
  [avoidClasses(clPlayer, 20, clForest, 17, clHill, 0), stayClasses(clLand, 4)],
  clForest,
  1,
  ...rBiomeTreeCount(1));
 RMS.SetProgress(50);
 
 log("Creating dirt patches...");
 createLayeredPatches(
  [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
  [[tMainTerrain,tTier1Terrain],[tTier1Terrain,tTier2Terrain], [tTier2Terrain,tTier3Terrain]],
  [1,1],
  [avoidClasses(clForest, 0, clHill, 0, clDirt, 3, clPlayer, 12), stayClasses(clLand, 7)]
 );
 
 log("Creating grass patches...");
 createPatches(
  [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
  tTier4Terrain,
  [avoidClasses(clForest, 0, clHill, 0, clDirt, 3, clPlayer, 12), stayClasses(clLand, 7)]
 );
 RMS.SetProgress(55);
 
 log("Creating stone mines...");
 createMines(
  [
   [new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)],
   [new SimpleObject(oStoneSmall, 2,5, 1,3)]
  ],
  [avoidClasses(clForest, 1, clPlayer, 7, clRock, 10, clHill, 1), stayClasses(clLand, 6)]
 );
 
 log("Creating metal mines...");
 createMines(
  [
   [new SimpleObject(oMetalLarge, 1,1, 0,4)]
  ],
  [avoidClasses(clForest, 1, clPlayer, 7, clMetal, 10, clRock, 5, clHill, 1), stayClasses(clLand, 6)],
  clMetal
 );
 RMS.SetProgress(65);
 
 log("Creating decoration...");
 var planetm = currentBiome() == "tropic" ? 8 : 1;
 createDecoration
 (
  [[new SimpleObject(aRockMedium, 1,3, 0,1)],
   [new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
   [new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)],
   [new SimpleObject(aGrass, 2,4, 0,1.8, -PI/8,PI/8), new SimpleObject(aGrassShort, 3,6, 1.2,2.5, -PI/8,PI/8)],
   [new SimpleObject(aBushMedium, 1,2, 0,2), new SimpleObject(aBushSmall, 2,4, 0,2)]
  ],
  [
   scaleByMapSize(16, 262),
   scaleByMapSize(8, 131),
   planetm * scaleByMapSize(13, 200),
   planetm * scaleByMapSize(13, 200),
   planetm * scaleByMapSize(13, 200)
  ],
  [avoidClasses(clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 5)]
 );
 RMS.SetProgress(70);
 
 log("Creating animals...");
 createFood
 (
  [
   [new SimpleObject(oMainHuntableAnimal, 5,7, 0,4)],
   [new SimpleObject(oSecondaryHuntableAnimal, 2,3, 0,2)]
  ],
  [
   3 * numPlayers,
   3 * numPlayers
  ],
  [avoidClasses(clForest, 0, clPlayer, 1, clHill, 1, clFood, 20), stayClasses(clLand, 3)]
 );
 RMS.SetProgress(75);
 
 log("Creating fruits...");
 createFood
 (
  [
   [new SimpleObject(oFruitBush, 5,7, 0,4)]
  ],
  [
   3 * numPlayers
  ],
  [avoidClasses(clForest, 0, clPlayer, 1, clHill, 1, clFood, 10), stayClasses(clLand, 3)]
 );
 RMS.SetProgress(80);
 
 log("Creating fish...");
 createFood
 (
  [
   [new SimpleObject(oFish, 2,3, 0,2)]
  ],
  [
   25 * numPlayers
  ],
  avoidClasses(clLand, 3, clPlayer, 2, clFood, 20)
 );
 
 RMS.SetProgress(85);
 
 log("Creating straggler trees...");
 var types = [oTree1, oTree2, oTree4, oTree3];	// some variation
 createStragglerTrees(types, [avoidClasses(clForest, 7, clHill, 1, clPlayer, 3, clMetal, 6, clRock, 6), stayClasses(clLand, 7)]);
 setWaterWaviness(4.0);
 setWaterType("ocean");
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/arctic_summer.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/arctic_summer.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/arctic_summer.js	(revision 20149)
@@ -1,376 +1,372 @@
 RMS.LoadLibrary("rmgen");
 
 setFogThickness(0.46);
 setFogFactor(0.5);
 
 setPPEffect("hdr");
 setPPSaturation(0.48);
 setPPContrast(0.53);
 setPPBloom(0.12);
 
 var tPrimary = ["alpine_grass_rocky"];
 var tForestFloor = "alpine_grass";
 var tCliff = ["polar_cliff_a", "polar_cliff_b", "polar_cliff_snow"];
 var tSecondary = "alpine_grass";
 var tHalfSnow = ["polar_grass_snow", "ice_dirt"];
 var tSnowLimited = ["polar_snow_rocks", "polar_ice"];
 var tDirt = "ice_dirt";
 var tShore = "alpine_shore_rocks";
 var tWater = "polar_ice_b";
 var tHill = "polar_ice_cracked";
 
 var oBush = "gaia/flora_bush_badlands";
 var oBush2 = "gaia/flora_bush_temperate";
 var oBerryBush = "gaia/flora_bush_berry";
 var oRabbit = "gaia/fauna_rabbit";
 var oMuskox = "gaia/fauna_muskox";
 var oDeer = "gaia/fauna_deer";
 var oWolf = "gaia/fauna_wolf";
 var oWhaleFin = "gaia/fauna_whale_fin";
 var oWhaleHumpback = "gaia/fauna_whale_humpback";
 var oFish = "gaia/fauna_fish";
 var oStoneLarge = "gaia/geology_stonemine_alpine_quarry";
 var oStoneSmall = "gaia/geology_stone_alpine_a";
 var oMetalLarge = "gaia/geology_metal_alpine_slabs";
 var oWood = "gaia/special_treasure_wood";
 
 var aRockLarge = "actor|geology/stone_granite_med.xml";
 var aRockMedium = "actor|geology/stone_granite_med.xml";
 
 const pForest = [tForestFloor + TERRAIN_SEPARATOR + oBush, tForestFloor + TERRAIN_SEPARATOR + oBush2, tForestFloor];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 
 initTerrain(tPrimary);
 
-var playerIDs = sortAllPlayers();
+var [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
-var startAngle = randFloat(0, 2 * PI);
 for (let i = 0; i < numPlayers; i++)
 {
 	log("Creating base for player " + playerIDs[i]);
-	let playerAngle = startAngle + i * 2 * PI / numPlayers;
-	let playerX = 0.5 + 0.35 * Math.cos(playerAngle);
-	let playerZ = 0.5 + 0.35 * Math.sin(playerAngle);
 	let radius = scaleByMapSize(15, 25);
 
 	// Get the x and z in tiles
-	let fx = fractionToTiles(playerX);
-	let fz = fractionToTiles(playerZ);
+	let fx = fractionToTiles(playerX[i]);
+	let fz = fractionToTiles(playerZ[i]);
 	let ix = Math.round(fx);
 	let iz = Math.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
 	let cityRadius = radius / 3;
 	createArea(
 		new ClumpPlacer(PI * cityRadius * cityRadius, 0.6, 0.3, 10, ix, iz),
 		new LayeredPainter([tPrimary, tSecondary], [1]),
 		null);
 
 	placeCivDefaultEntities(fx, fz, playerIDs[i]);
 
 	placeDefaultChicken(fx, fz, clBaseResource, undefined, oRabbit);
 
 	// Create berry bushes
 	let bbAngle = randFloat(0, 2 * PI);
 	let bbDist = 12;
 	createObjectGroup(
 		new SimpleGroup(
 			[new SimpleObject(oBerryBush, 5, 5, 0, 3)],
 			true,
 			clBaseResource,
 			Math.round(fx + bbDist * Math.cos(bbAngle)),
 			Math.round(fz + bbDist * Math.sin(bbAngle))),
 		0);
 
 	// Create metal mine
 	let mAngle = bbAngle + randFloat(PI / 3, PI);
 	let mDist = 12;
 	createObjectGroup(
 		new SimpleGroup(
 			[new SimpleObject(oMetalLarge, 1, 1, 0, 0)],
 			true,
 			clBaseResource,
 			Math.round(fx + mDist * Math.cos(mAngle)),
 			Math.round(fz + mDist * Math.sin(mAngle))),
 		0);
 
 	// Create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	createObjectGroup(
 		new SimpleGroup(
 			[new SimpleObject(oStoneLarge, 1, 1, 0, 2)],
 			true,
 			clBaseResource,
 			Math.round(fx + mDist * Math.cos(mAngle)),
 			Math.round(fz + mDist * Math.sin(mAngle))),
 		0);
 
 	// Create wood treasure
 	mAngle += randFloat(PI/4, PI/6);
 	createObjectGroup(
 		new SimpleGroup(
 			[new SimpleObject(oWood, 10, 10, 0, 3)],
 			true,
 			clBaseResource,
 			Math.round(fx + bbDist * Math.cos(mAngle)),
 			Math.round(fz + bbDist * Math.sin(mAngle)),
 			avoidClasses(clBaseResource, 4)),
 		0);
 
 	// Create starting trees
 	for (let i = 0; i < 10; ++i)
 	{
 		let tAngle = mAngle + randFloat(PI/3, PI/4);
 		let tDist = randFloat(10, 12);
 		if (createObjectGroup(
 			new SimpleGroup(
 				[new SimpleObject(oBush, 20, 20, 0, 3)],
 				false,
 				clBaseResource,
 				Math.round(fx + tDist * Math.cos(tAngle)),
 				Math.round(fz + tDist * Math.sin(tAngle))),
 			0,
 			avoidClasses(clBaseResource, 4)))
 		{
 			break;
 		}
 	}
 }
 RMS.SetProgress(20);
 
 log("Creating hills...");
 createHills(
 	[tPrimary, tCliff, tHill],
 	avoidClasses(
 		clPlayer, 35,
 		clForest, 20,
 		clHill, 50,
 		clWater, 2),
 	clHill,
 	scaleByMapSize(1, 240));
 
 RMS.SetProgress(30);
 
 log("Creating lakes...");
 createAreas(
 	new ChainPlacer(
 		1,
 		Math.floor(scaleByMapSize(4, 8)),
 		Math.floor(scaleByMapSize(40, 180)),
 		1),
 	[
 		new LayeredPainter([tShore, tWater, tWater], [1, 3]),
 		new SmoothElevationPainter(ELEVATION_SET, -5, 5),
 		paintClass(clWater)
 	],
 	avoidClasses(clPlayer, 15),
 	scaleByMapSize(1, 20));
 
 RMS.SetProgress(45);
 
 log("Creating bumps...");
 createBumps(avoidClasses(clPlayer, 6, clWater, 2), scaleByMapSize(30, 300), 1, 8, 4, 0, 3);
 
 paintTerrainBasedOnHeight(4, 15, 0, tCliff);
 paintTerrainBasedOnHeight(15, 100, 3, tSnowLimited);
 
 createForests(
 	[tSecondary, tForestFloor, tForestFloor, pForest, pForest],
 	avoidClasses(
 		clPlayer, 20,
 		clForest, 14,
 		clHill, 20,
 		clWater, 2),
 	clForest,
 	1);
 RMS.SetProgress(60);
 
 log("Creating dirt patches...");
 createLayeredPatches(
 	[scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
 	[[tDirt,tHalfSnow], [tHalfSnow,tSnowLimited]],
 	[2],
 	avoidClasses(
 		clWater, 3,
 		clForest, 0,
 		clHill, 0,
 		clDirt, 5,
 		clPlayer, 12));
 
 log("Creating shrubs...");
 createPatches(
 	[scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
 	tSecondary,
 	avoidClasses(
 		clWater, 3,
 		clForest, 0,
 		clHill, 0,
 		clDirt, 5,
 		clPlayer, 12));
 
 log("Creating grass patches...");
 createPatches(
 	[scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
 	tSecondary,
 	avoidClasses(
 		clWater, 3,
 		clForest, 0,
 		clHill, 0,
 		clDirt, 5,
 		clPlayer, 12));
 RMS.SetProgress(65);
 
 log("Creating stone mines...");
 createMines(
 	[
 		[new SimpleObject(oStoneSmall, 0, 2, 0, 4), new SimpleObject(oStoneLarge, 1, 1, 0, 4)],
 		[new SimpleObject(oStoneSmall, 2, 5, 1, 3)]
 	],
 	avoidClasses(
 		clWater, 3,
 		clForest, 1,
 		clPlayer, 20,
 		clRock, 18,
 		clHill, 1));
 
 log("Creating metal mines...");
 createMines(
 	[
 		[new SimpleObject(oMetalLarge, 1, 1, 0, 4)]
 	],
 	avoidClasses(
 		clWater, 3,
 		clForest, 1,
 		clPlayer, 20,
 		clMetal, 18,
 		clRock, 5,
 		clHill, 1),
 	clMetal);
 RMS.SetProgress(70);
 
 createDecoration(
 	[
 		[
 			new SimpleObject(aRockMedium, 1, 3, 0, 1)
 		],
 		[
 			new SimpleObject(aRockLarge, 1, 2, 0, 1),
 			new SimpleObject(aRockMedium, 1, 3, 0, 1)
 		]
 	],
 	[
 		scaleByMapSize(16, 262),
 		scaleByMapSize(8, 131),
 	],
 	avoidClasses(
 		clWater, 0,
 		clForest, 0,
 		clPlayer, 0,
 		clHill, 0));
 RMS.SetProgress(75);
 
 createFood(
 	[
 		[new SimpleObject(oWolf, 3, 5, 0, 3)],
 		[new SimpleObject(oRabbit, 6, 8, 0, 6)],
 		[new SimpleObject(oDeer, 3, 4, 0, 3)],
 		[new SimpleObject(oMuskox, 3, 4, 0, 3)]
 	],
 	[
 		3 * numPlayers,
 		3 * numPlayers,
 		3 * numPlayers,
 		3 * numPlayers
 	],
 	avoidClasses(
 		clFood, 20,
 		clHill, 5,
 		clWater, 5));
 
 createFood
 (
 	[
 		[new SimpleObject(oWhaleFin, 1, 1, 0, 3)],
 		[new SimpleObject(oWhaleHumpback, 1, 1, 0, 3)]
 	],
 	[
 		3 * numPlayers,
 		3 * numPlayers
 	],
 	[
 		avoidClasses(clFood, 20),
 		stayClasses(clWater, 6)
 	]);
 
 createFood
 (
 	[
 		[new SimpleObject(oBerryBush, 5, 7, 0, 4)]
 	],
 	[
 		randIntInclusive(1, 4) * numPlayers + 2
 	],
 	avoidClasses(
 		clWater, 3,
 		clForest, 0,
 		clPlayer, 20,
 		clHill, 1,
 		clFood, 10));
 
 createFood(
 	[
 		[new SimpleObject(oFish, 2, 3, 0, 2)]
 	],
 	[
 		15 * numPlayers
 	],
 	[
 		avoidClasses(clFood, 20),
 		stayClasses(clWater, 6)
 	]);
 
 RMS.SetProgress(85);
 
 createStragglerTrees(
 	[oBush, oBush2],
 	avoidClasses(
 		clWater, 5,
 		clForest, 3,
 		clHill, 1,
 		clPlayer, 12,
 		clMetal, 4,
 		clRock, 4));
 
 setSkySet("sunset 1");
 setSunRotation(randFloat(0, 2 * PI));
 setSunColor(0.8, 0.7, 0.6);
 setTerrainAmbientColor(0.7, 0.6, 0.7);
 setUnitsAmbientColor(0.6, 0.5, 0.6);
 setSunElevation(randFloat(PI/12, PI/7));
 setWaterColor(0, 0.047, 0.286);
 setWaterTint(0.462, 0.756, 0.866);
 setWaterMurkiness(0.92);
 setWaterWaviness(1);
 setWaterType("clap");
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/ardennes_forest.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/ardennes_forest.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/ardennes_forest.js	(revision 20149)
@@ -1,592 +1,580 @@
 RMS.LoadLibrary("rmgen");
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 
 const tGrass = ["new_alpine_grass_b", "new_alpine_grass_c", "new_alpine_grass_d"];
 const tPineForestFloor = "temp_forestfloor_pine";
 const tForestFloor = [tPineForestFloor, tPineForestFloor, "alpine_dirt_grass_50"];
 const tCliff = ["alpine_cliff_c", "alpine_cliff_c", "alpine_grass_rocky"];
 const tCity = ["new_alpine_citytile", "new_alpine_grass_dirt_a"];
 const tGrassPatch = ["alpine_grass_a", "alpine_grass_b"];
 
 const oBoar = "gaia/fauna_boar";
 const oDeer = "gaia/fauna_deer";
 const oBear = "gaia/fauna_bear";
 const oPig = "gaia/fauna_pig";
 const oBerryBush = "gaia/flora_bush_berry";
 const oMetalSmall = "gaia/geology_metal_alpine";
 const oMetalLarge = "gaia/geology_metal_temperate_slabs";
 const oStoneSmall = "gaia/geology_stone_alpine_a";
 const oStoneLarge = "gaia/geology_stonemine_temperate_quarry";
 
 const oOak = "gaia/flora_tree_oak";
 const oOakLarge = "gaia/flora_tree_oak_large";
 const oPine = "gaia/flora_tree_pine";
 const oAleppoPine = "gaia/flora_tree_aleppo_pine";
 
 const aTreeA = "actor|flora/trees/oak.xml";
 const aTreeB = "actor|flora/trees/oak_large.xml";
 const aTreeC = "actor|flora/trees/pine.xml";
 const aTreeD = "actor|flora/trees/aleppo_pine.xml";
 
 const aTrees = [aTreeA, aTreeB, aTreeC, aTreeD];
 
 const aGrassLarge = "actor|props/flora/grass_soft_large.xml";
 const aWoodLarge = "actor|props/special/eyecandy/wood_pile_1_b.xml";
 const aWoodA = "actor|props/special/eyecandy/wood_sm_pile_a.xml";
 const aWoodB = "actor|props/special/eyecandy/wood_sm_pile_b.xml";
 const aBarrel = "actor|props/special/eyecandy/barrel_a.xml";
 const aWheel = "actor|props/special/eyecandy/wheel_laying.xml";
 const aCeltHomestead = "actor|structures/celts/homestead.xml";
 const aCeltHouse = "actor|structures/celts/house.xml";
 const aCeltLongHouse = "actor|structures/celts/longhouse.xml";
 
 var pForest = [
 		tPineForestFloor+TERRAIN_SEPARATOR+oOak, tForestFloor,
 		tPineForestFloor+TERRAIN_SEPARATOR+oPine, tForestFloor,
 		tPineForestFloor+TERRAIN_SEPARATOR+oAleppoPine, tForestFloor,
 		tForestFloor
 		];
 
 var clPlayer = createTileClass();
 var clPath = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clForestJoin = createTileClass();
 var clWater = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clPlayable = createTileClass();
 var clHillDeco = createTileClass();
 
 // Create central dip
 var centerX = fractionToTiles(0.5);
 var centerZ = fractionToTiles(0.5);
 
 var placer = new ClumpPlacer(scaleByMapSize(mapSize * 70, mapSize * 300), 0.94, 0.05, 0.1, centerX, centerZ);
 var elevationPainter = new SmoothElevationPainter(
 	    ELEVATION_SET,
 	    30,
 	    3
     );
 var painter = new LayeredPainter(
 		[tCliff, tGrass],		// terrains
 		[3]		// widths
 	);
 createArea(placer,
 	[painter, elevationPainter],
 	null);
 
 RMS.SetProgress(5);
 
 // Find all hills
 var noise0 = new Noise2D(20);
 for (var ix = 0; ix < mapSize; ix++)
 	for (var iz = 0; iz < mapSize; iz++)
 	{
 		var h = getHeight(ix,iz);
 		if(h > 40){
 			addToClass(ix,iz,clHill);
 
 			// Add hill noise
 			var x = ix / (mapSize + 1.0);
 			var z = iz / (mapSize + 1.0);
 			var n = (noise0.get(x,z) - 0.5) * 40;
 			setHeight(ix, iz, h + n);
 		}
 	}
 
-var playerIDs = sortAllPlayers();
-
-var playerX = new Array(numPlayers);
-var playerZ = new Array(numPlayers);
-var playerAngle = new Array(numPlayers);
-
-var startAngle = randFloat(0, 2 * PI);
-for (var i=0; i < numPlayers; i++)
-{
-	playerAngle[i] = startAngle + i*2*PI/numPlayers;
-	playerX[i] = 0.5 + 0.3*cos(playerAngle[i]);
-	playerZ[i] = 0.5 + 0.3*sin(playerAngle[i]);
-}
+var [playerIDs, playerX, playerZ] = radialPlayerPlacement(0.3);
 
 function distanceToPlayers(x, z)
 {
 	var r = 10000;
 	for (var i = 0; i < numPlayers; i++)
 	{
 		var dx = x - playerX[i];
 		var dz = z - playerZ[i];
 		r = min(r, dx*dx + dz*dz);
 	}
 	return sqrt(r);
 }
 
 function playerNearness(x, z)
 {
 	var d = fractionToTiles(distanceToPlayers(x,z));
 
 	if (d < 13)
 		return 0;
 
 	if (d < 19)
 		return (d-13)/(19-13);
 
 	return 1;
 }
 
 RMS.SetProgress(10);
 
 for (var i=0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	var citySize = 250;
 
 	var placer = new ClumpPlacer(citySize, 0.95, 0.3, 0.1, ix, iz);
 	createArea(placer, [paintClass(clPlayer)], null);
 
 	// Create the city patch
 	var placer = new ClumpPlacer(citySize * 0.4, 0.6, 0.05, 10, ix, iz);
 	var painter = new TerrainPainter([tCity]);
 	createArea(placer, painter, null);
 
 	// Create starter animals
 	placeDefaultChicken(fx, fz, clBaseResource, undefined, oPig);
 
 	// Create starter berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oBerryBush, 3,3, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// Create starter metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = bbDist + 4;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// Create starter stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var num = 2;
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(11, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oOak, num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 }
 
 RMS.SetProgress(30);
 
 log("Creating hills...");
 var sizes = [scaleByMapSize(50, 800), scaleByMapSize(50, 400), scaleByMapSize(10, 30), scaleByMapSize(10, 30)];
 for (var i = 0; i < sizes.length; i++)
 {
 	var placer = new ClumpPlacer(sizes[i], 0.1, 0.2, 0.1);
 	var painter = new LayeredPainter(
 		[tCliff, [tForestFloor, tForestFloor, tCliff]],		// terrains
 		[2]		// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 	    ELEVATION_SET,
 	    50,
 	    sizes[i] < 50 ? 2 : 4
     );
 
 	var mountains = createAreas(
 		placer,
 		[painter, paintClass(clHill), elevationPainter],
 		avoidClasses(clPlayer, 8, clBaseResource, 2, clHill, 5),
 		scaleByMapSize(1, 4)
 	);
 
 	if(sizes[i] > 100 && mountains.length > 0)
 	{
 		var placer = new ClumpPlacer(sizes[i] * 0.3, 0.94, 0.05, 0.1);
 		var elevationPainter = new SmoothElevationPainter(
 				 ELEVATION_MODIFY,
 				 10,
 				 3
 			 );
 		var painter = new LayeredPainter(
 			[tCliff, tForestFloor],		// terrains
 			[2]		// widths
 		);
 
 		createAreasInAreas(
 			placer,
 			[painter, elevationPainter],
 			stayClasses(clHill, 4),
 			mountains.length * 2,
 			20,
 			mountains
 		);
 	}
 
 	var placer = new ClumpPlacer(sizes[i], 0.1, 0.2, 0.1);
 
 	var elevationPainter = new SmoothElevationPainter(
 	    ELEVATION_SET,
 	    10,
 	    2
     );
 
 	var ravine = createAreas(
 		placer,
 		[painter, paintClass(clHill), elevationPainter],
 		avoidClasses(clPlayer, 6, clBaseResource, 2, clHill, 5),
 		scaleByMapSize(1, 3)
 	);
 
 	if(sizes[i] > 150 && ravine.length > 0)
 	{
 		// Place huts in ravines
 		var group = new RandomGroup(
 		[
 			new SimpleObject(aCeltHouse, 0,1, 4,5),
 			new SimpleObject(aCeltLongHouse, 1,1, 4,5)
 		], true, clHillDeco);
 		createObjectGroupsByAreasDeprecated(
 			group, 0,
 			[avoidClasses(clHillDeco, 3), stayClasses(clHill, 3)],
 			ravine.length * 5, 20,
 			ravine
 		);
 
 		var group = new RandomGroup(
 		[
 			new SimpleObject(aCeltHomestead, 1,1, 1,1)
 		], true, clHillDeco);
 		createObjectGroupsByAreasDeprecated(
 			group, 0,
 			[avoidClasses(clHillDeco, 5), stayClasses(clHill, 4)],
 			ravine.length * 2, 100,
 			ravine
 		);
 
 		// Place noise
 		var placer = new ClumpPlacer(sizes[i] * 0.3, 0.94, 0.05, 0.1);
 		var elevationPainter = new SmoothElevationPainter(
 				 ELEVATION_SET,
 				 2,
 				 2
 			 );
 		var painter = new LayeredPainter(
 			[tCliff, tForestFloor],		// terrains
 			[2]		// widths
 		);
 
 		createAreasInAreas(
 			placer,
 			[painter, elevationPainter],
 			[avoidClasses(clHillDeco, 2), stayClasses(clHill, 0)],
 			ravine.length * 2,
 			20,
 			ravine
 		);
 
 		var placer = new ClumpPlacer(sizes[i] * 0.1, 0.3, 0.05, 0.1);
 		var elevationPainter = new SmoothElevationPainter(
 				 ELEVATION_SET,
 				 40,
 				 2
 			 );
 		var painter = new LayeredPainter(
 			[tCliff, tForestFloor],		// terrains
 			[2]		// widths
 		);
 
 		createAreasInAreas(
 			placer,
 			[painter, paintClass(clHill), elevationPainter],
 			[avoidClasses(clHillDeco, 2), borderClasses(clHill, 15, 1)],
 			ravine.length * 2,
 			50,
 			ravine
 		);
 	}
 
 	RMS.SetProgress(30 + (20 * (i / sizes.length)));
 }
 
 RMS.SetProgress(50);
 
 var explorableArea = {};
 explorableArea.points = [];
 
 var playerClass = getTileClass(clPlayer);
 var hillDecoClass = getTileClass(clHillDeco);
 
 for (var ix = 0; ix < mapSize; ix++)
 {
 	for (var iz = 0; iz < mapSize; iz++)
 	{
 		var h = getHeight(ix,iz);
 
 		if(h > 15 && h < 45 && playerClass.countMembersInRadius(ix, iz, 1) == 0)
 		{
 			// explorable area
 			var pt = {};
 			pt.x = ix;
 			pt.z = iz;
 			explorableArea.points.push(pt);
 		}
 
 		if (h > 35 && g_Map.validT(ix, iz) && randBool(0.1) ||
 		    h < 15 && g_Map.validT(ix, iz) && randBool(0.05) && hillDecoClass.countMembersInRadius(ix, iz, 1) == 0)
 			placeObject(ix + randFloat(0, 1), iz + randFloat(0, 1), pickRandom(aTrees), 0, randFloat(0, 2 * PI));
 	}
 }
 
 RMS.SetProgress(55);
 
 // Add some general noise - after placing height dependant trees
 for (var ix = 0; ix < mapSize; ix++)
 {
 	var x = ix / (mapSize + 1.0);
 	for (var iz = 0; iz < mapSize; iz++)
 	{
 		var z = iz / (mapSize + 1.0);
 		var h = getHeight(ix,iz);
 		var pn = playerNearness(x,z);
 		var n = (noise0.get(x,z) - 0.5) * 10;
 		setHeight(ix, iz, h + (n * pn));
 	}
 }
 
 RMS.SetProgress(60);
 
 // Calculate desired number of trees for map (based on size)
 const MIN_TREES = 400;
 const MAX_TREES = 6000;
 const P_FOREST = 0.8;
 const P_FOREST_JOIN = 0.25;
 
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 var numForest = totalTrees * P_FOREST * (1.0 - P_FOREST_JOIN);
 var numForestJoin = totalTrees * P_FOREST * P_FOREST_JOIN;
 var numStragglers = totalTrees * (1.0 - P_FOREST);
 
 log("Creating forests...");
 var num = numForest / (scaleByMapSize(6,16) * numPlayers);
 placer = new ClumpPlacer(numForest / num, 0.1, 0.1, 1);
 painter = new TerrainPainter(pForest);
 createAreasInAreas(
 	placer,
 	[painter, paintClass(clForest)],
 	avoidClasses(clPlayer, 5, clBaseResource, 4, clForest, 6, clHill, 4),
 	num,
 	100,
 	[explorableArea]
 );
 
 var num = numForestJoin / (scaleByMapSize(4,6) * numPlayers);
 placer = new ClumpPlacer(numForestJoin / num, 0.1, 0.1, 1);
 painter = new TerrainPainter(pForest);
 createAreasInAreas(
 	placer,
 	[painter, paintClass(clForest), paintClass(clForestJoin)],
 	[avoidClasses(clPlayer, 5, clBaseResource, 4, clForestJoin, 5, clHill, 4), borderClasses(clForest, 1, 4)],
 	num,
 	100,
 	[explorableArea]
 );
 
 RMS.SetProgress(70);
 
 log("Creating grass patches...");
 var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
 for (var i = 0; i < sizes.length; i++)
 {
 	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
 	painter = new LayeredPainter(
 		[[tGrass,tGrassPatch],[tGrassPatch,tGrass], [tGrass,tGrassPatch]], 		// terrains
 		[1,1]															// widths
 	);
 	createAreas(
 		placer,
 		painter,
 		avoidClasses(clForest, 0, clHill, 2, clPlayer, 5),
 		scaleByMapSize(15, 45)
 	);
 }
 
 log("Creating chopped forest patches...");
 var sizes = [scaleByMapSize(20, 120)];
 for (var i = 0; i < sizes.length; i++)
 {
 	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
 	painter = new TerrainPainter(tForestFloor);
 	createAreas(
 		placer,
 		painter,
 		avoidClasses(clForest, 1, clHill, 2, clPlayer, 5),
 		scaleByMapSize(4, 12)
 	);
 }
 RMS.SetProgress(75);
 
 log("Creating stone mines...");
 var group = new SimpleGroup([new SimpleObject(oStoneSmall, 1,2, 0,4), new SimpleObject(oStoneLarge, 0,1, 0,4)], true, clRock);
 createObjectGroupsByAreasDeprecated(group, 0,
 	[avoidClasses(clHill, 4, clForest, 2, clPlayer, 20, clRock, 10)],
 	scaleByMapSize(6,20), 100,
 	[explorableArea]
 );
 
 log("Creating small stone mines...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroupsByAreasDeprecated(group, 0,
 	[avoidClasses(clHill, 4, clForest, 2, clPlayer, 20, clRock, 10)],
 	scaleByMapSize(6,20), 100,
 	[explorableArea]
 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalSmall, 1,2, 0,4), new SimpleObject(oMetalLarge, 0,1, 0,4)], true, clMetal);
 createObjectGroupsByAreasDeprecated(group, 0,
 	[avoidClasses(clHill, 4, clForest, 2, clPlayer, 20, clMetal, 10, clRock, 5)],
 	scaleByMapSize(6,20), 100,
 	[explorableArea]
 );
 
 RMS.SetProgress(80);
 
 log("Creating wildlife...");
 group = new SimpleGroup(
 	[new SimpleObject(oDeer, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsByAreasDeprecated(group, 0,
 	avoidClasses(clHill, 4, clForest, 0, clPlayer, 0, clBaseResource, 20),
 	3 * numPlayers, 100,
 	[explorableArea]
 );
 
 group = new SimpleGroup(
 	[new SimpleObject(oBoar, 2,3, 0,5)],
 	true, clFood
 );
 createObjectGroupsByAreasDeprecated(group, 0,
 	avoidClasses(clHill, 4, clForest, 0, clPlayer, 0, clBaseResource, 15),
 	numPlayers, 50,
 	[explorableArea]
 );
 
 group = new SimpleGroup(
 	[new SimpleObject(oBear, 1,1, 0,4)],
 	false, clFood
 );
 createObjectGroupsByAreasDeprecated(group, 0,
 	avoidClasses(clHill, 4, clForest, 0, clPlayer, 20),
 	scaleByMapSize(3, 12), 200,
 	[explorableArea]
 );
 
 RMS.SetProgress(85);
 
 log("Creating berry bush...");
 group = new SimpleGroup(
 	[new SimpleObject(oBerryBush, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 4, clFood, 20),
 	randIntInclusive(3, 12) * numPlayers + 2, 50
 );
 
 log("Creating decorative props...");
 group = new SimpleGroup(
 	[
 		new SimpleObject(aWoodA, 1,2, 0,1),
 		new SimpleObject(aWoodB, 1,3, 0,1),
 		new SimpleObject(aWheel, 0,2, 0,1),
 		new SimpleObject(aWoodLarge, 0,1, 0,1),
 		new SimpleObject(aBarrel, 0,2, 0,1)
 	],
 	true
 );
 createObjectGroupsByAreasDeprecated(
 	group, 0,
 	avoidClasses(clForest, 0),
 	scaleByMapSize(5, 50), 50,
 	[explorableArea]
 );
 
 RMS.SetProgress(90);
 
 log("Creating straggler trees...");
 var types = [oOak, oOakLarge, oPine, oAleppoPine];	// some variation
 var num = floor(numStragglers / types.length);
 for (var i = 0; i < types.length; ++i)
 {
 	group = new SimpleGroup(
 		[new SimpleObject(types[i], 1,1, 0,3)],
 		true, clForest
 	);
 
 	createObjectGroupsByAreasDeprecated(group, 0,
 		avoidClasses(clForest, 4, clHill, 5, clPlayer, 10, clBaseResource, 2, clMetal, 5, clRock, 5),
 		num, 20,
 		[explorableArea]
 	);
 }
 
 RMS.SetProgress(95);
 
 log("Creating grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aGrassLarge, 1,2, 0,1, -PI/8,PI/8)]
 );
 createObjectGroupsByAreasDeprecated(group, 0,
 	avoidClasses(clHill, 2, clPlayer, 2),
 	scaleByMapSize(50, 300), 20,
 	[explorableArea]
 );
 
 setTerrainAmbientColor(0.44,0.51,0.56);
 setUnitsAmbientColor(0.44,0.51,0.56);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/atlas_mountains.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/atlas_mountains.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/atlas_mountains.js	(revision 20149)
@@ -1,298 +1,286 @@
 RMS.LoadLibrary("rmgen");
 
 const tGrass = ["medit_rocks_grass_shrubs", "medit_rocks_shrubs"];
 const tForestFloor = "medit_grass_field_dry";
 const tCliff = "medit_cliff_italia";
 const tHill = ["medit_rocks_grass", "medit_rocks_grass_shrubs", "medit_rocks_shrubs"];
 const tGrassDirt = "medit_rocks_grass";
 const tDirt = "medit_dirt";
 const tRoad = "medit_city_tile";
 const tRoadWild = "medit_city_tile";
 const tGrass2 = "medit_rocks_grass_shrubs";
 const tGrassPatch = "medit_grass_wild";
 const tShoreBlend = "medit_sand";
 const tShore = "medit_sand";
 const tWater = "medit_sand";
 
 const oCarob = "gaia/flora_tree_carob";
 const oAleppoPine = "gaia/flora_tree_aleppo_pine";
 const oBerryBush = "gaia/flora_bush_berry";
 const oDeer = "gaia/fauna_deer";
 const oFish = "gaia/fauna_fish";
 const oSheep = "gaia/fauna_sheep";
 const oStoneLarge = "gaia/geology_stonemine_medit_quarry";
 const oStoneSmall = "gaia/geology_stone_mediterranean";
 const oMetalLarge = "gaia/geology_metal_mediterranean_slabs";
 const oWood = "gaia/special_treasure_wood";
 const oFood = "gaia/special_treasure_food_bin";
 
 const aGrass = "actor|props/flora/grass_soft_large_tall.xml";
 const aGrassShort = "actor|props/flora/grass_soft_large.xml";
 const aRockLarge = "actor|geology/stone_granite_large.xml";
 const aRockMedium = "actor|geology/stone_granite_med.xml";
 const aBushMedium = "actor|props/flora/bush_medit_me.xml";
 const aBushSmall = "actor|props/flora/bush_medit_sm.xml";
 const aCarob = "actor|flora/trees/carob.xml";
 const aAleppoPine = "actor|flora/trees/aleppo_pine.xml";
 
 // terrain + entity (for painting)
 const pForest1 = [tForestFloor + TERRAIN_SEPARATOR + oCarob, tForestFloor];
 const pForest2 = [tForestFloor + TERRAIN_SEPARATOR + oAleppoPine, tForestFloor];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 const mapArea = mapSize*mapSize;
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clTreasure = createTileClass();
 var clGrass = createTileClass();
 
-var playerIDs = sortAllPlayers();
-
-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 [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 	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);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oBerryBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 	// create starting trees
 	var num = 4;
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(11, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oCarob, num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 
 RMS.SetProgress(10);
 
 createBumps(avoidClasses(clPlayer, 9));
 
 createMountains(tCliff, avoidClasses(clPlayer, 20, clHill, 8), clHill, scaleByMapSize(20, 120));
 
 RMS.SetProgress(25);
 
 createForests(
  [tGrass, tForestFloor, tForestFloor, pForest1, pForest2],
  avoidClasses(clPlayer, 20, clForest, 14, clHill, 1),
  clForest,
  0.6);
 
 RMS.SetProgress(40);
 
 log("Creating dirt patches...");
 createLayeredPatches(
  [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
  [tGrassDirt,tDirt],
  [2],
  avoidClasses(clForest, 0, clHill, 0, clDirt, 3, clPlayer, 10)
 );
 
 log("Creating grass patches...");
 createLayeredPatches(
  [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
  [tGrass2,tGrassPatch],
  [1],
  avoidClasses(clForest, 0, clHill, 0, clDirt, 3, clPlayer, 10, clGrass, 15)
 );
 
 RMS.SetProgress(50);
 
 log("Creating stone mines...");
 createMines(
  [
   [new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)],
   [new SimpleObject(oStoneSmall, 2,5, 1,3)]
  ],
  avoidClasses(clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 2)
 );
 
 log("Creating metal mines...");
 createMines(
  [
   [new SimpleObject(oMetalLarge, 1,1, 0,4)]
  ],
  avoidClasses(clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 2),
  clMetal
 );
 
 RMS.SetProgress(60);
 
 createDecoration
 (
  [[new SimpleObject(aRockMedium, 1,3, 0,1)],
   [new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
   [new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)],
   [new SimpleObject(aGrass, 2,4, 0,1.8, -PI/8,PI/8), new SimpleObject(aGrassShort, 3,6, 1.2,2.5, -PI/8,PI/8)],
   [new SimpleObject(aBushMedium, 1,2, 0,2), new SimpleObject(aBushSmall, 2,4, 0,2)]
  ],
  [
   scaleByMapSize(16, 262),
   scaleByMapSize(8, 131),
   scaleByMapSize(13, 200),
   scaleByMapSize(13, 200),
   scaleByMapSize(13, 200)
  ],
  avoidClasses(clForest, 0, clPlayer, 0, clHill, 0)
 );
 
 RMS.SetProgress(75);
 
 createFood
 (
  [
   [new SimpleObject(oSheep, 5,7, 0,4)],
   [new SimpleObject(oDeer, 2,3, 0,2)]
  ],
  [
   3 * numPlayers,
   3 * numPlayers
  ]
 );
 
 createFood
 (
  [
   [new SimpleObject(oBerryBush, 5,7, 0,4)]
  ],
  [
   randIntInclusive(3, 12) * numPlayers + 2
  ],
  avoidClasses(clForest, 0, clPlayer, 20, clHill, 1, clFood, 10)
 );
 
 log("Creating food treasures...");
 group = new SimpleGroup(
 	[new SimpleObject(oFood, 2,3, 0,2)],
 	true, clTreasure
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 18, clHill, 1, clFood, 5),
 	3 * numPlayers, 50
 );
 
 log("Creating food treasures...");
 group = new SimpleGroup(
 	[new SimpleObject(oWood, 2,3, 0,2)],
 	true, clTreasure
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 18, clHill, 1),
 	3 * numPlayers, 50
 );
 
 RMS.SetProgress(80);
 
 var types = [oCarob, oAleppoPine];	// some variation
 createStragglerTrees(types, avoidClasses(clForest, 1, clHill, 1, clPlayer, 10, clMetal, 6, clRock, 6, clTreasure, 4));
 
 log("Creating hill trees...");
 var types = [aCarob, aAleppoPine];	// some variation
 var num = floor(0.2 * g_numStragglerTrees / types.length);
 for (var i = 0; i < types.length; ++i)
 {
 	group = new SimpleGroup(
 		[new SimpleObject(types[i], 1,1, 0,3)],
 		true, clForest
 	);
 	createObjectGroupsDeprecated(group, 0,
 		stayClasses(clHill, 2),
 		num
 	);
 }
 
 setFogFactor(0.2);
 setFogThickness(0.14);
 
 setPPEffect("hdr");
 setPPContrast(0.45);
 setPPSaturation(0.56);
 setPPBloom(0.1);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/botswanan_haven.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/botswanan_haven.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/botswanan_haven.js	(revision 20149)
@@ -1,471 +1,469 @@
 RMS.LoadLibrary("rmgen");
 
 const tGrassA = "savanna_shrubs_a_wetseason";
 const tGrassB = "savanna_shrubs_a";
 const tCliff = "savanna_cliff_a";
 const tHill = "savanna_grass_a_wetseason";
 const tMud = "savanna_mud_a";
 const tShoreBlend = "savanna_grass_b_wetseason";
 const tShore = "savanna_riparian_wet";
 const tWater = "savanna_mud_a";
 const tCityTile = "savanna_tile_a";
 
 const oBush = "gaia/flora_bush_temperate";
 const oBaobab = "gaia/flora_tree_baobab";
 const oToona = "gaia/flora_tree_toona";
 const oBerryBush = "gaia/flora_bush_berry";
 const oGazelle = "gaia/fauna_gazelle";
 const oZebra = "gaia/fauna_zebra";
 const oWildebeest = "gaia/fauna_wildebeest";
 const oLion = "gaia/fauna_lion";
 const oRhino = "gaia/fauna_rhino";
 const oCrocodile = "gaia/fauna_crocodile";
 const oElephant = "gaia/fauna_elephant_north_african";
 const oElephantInfant = "gaia/fauna_elephant_african_infant";
 const oLioness = "gaia/fauna_lioness";
 const oRabbit = "gaia/fauna_rabbit";
 const oStoneLarge = "gaia/geology_stonemine_temperate_quarry";
 const oStoneSmall = "gaia/geology_stone_savanna_small";
 const oMetalLarge = "gaia/geology_metal_savanna_slabs";
 
 const aGrass = "actor|props/flora/grass_field_lush_tall.xml";
 const aGrass2 = "actor|props/flora/grass_tropic_field_tall.xml";
 const aGrassShort = "actor|props/flora/grass_soft_large.xml";
 const aRockLarge = "actor|geology/stone_granite_med.xml";
 const aRockMedium = "actor|geology/stone_granite_med.xml";
 const aReeds = "actor|props/flora/reeds_pond_lush_a.xml";
 const aReeds2 = "actor|props/flora/reeds_pond_lush_b.xml";
 const aLillies = "actor|props/flora/water_lillies.xml";
 const aBushMedium = "actor|props/flora/bush_tropic_b.xml";
 const aBushSmall = "actor|props/flora/bush_tropic_a.xml";
 const aShrub = "actor|props/flora/shrub_tropic_plant_flower.xml";
 const aFlower = "actor|props/flora/flower_bright.xml";
 const aPalm = "actor|props/flora/shrub_fanpalm.xml";
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clForest = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 
-var playerIDs = sortAllPlayers();
+var [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
-var startAngle = randFloat(0, 2 * PI);
 for (let i = 0; i < numPlayers; ++i)
 {
-	let playerAngle = startAngle + i * 2 * PI / numPlayers;
 	let id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 	let radius = scaleByMapSize(15, 25);
 
 	// Get the x and z in tiles
-	let fx = fractionToTiles(0.5 + 0.35 * Math.cos(playerAngle));
-	let fz = fractionToTiles(0.5 + 0.35 * Math.sin(playerAngle));
+	let fx = fractionToTiles(playerX[i]);
+	let fz = fractionToTiles(playerZ[i]);
 	let ix = Math.round(fx);
 	let iz = Math.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
 	let cityRadius = radius / 3;
 	createArea(
 		new ClumpPlacer(PI * cityRadius * cityRadius, 0.6, 0.3, 10, ix, iz),
 		new LayeredPainter([tCityTile, tCityTile], [1]),
 		null);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// Create berry bushes
 	let bbAngle = randFloat(0, 2 * PI);
 	let bbDist = 12;
 	createObjectGroup(
 		new SimpleGroup(
 			[new SimpleObject(oBerryBush, 5, 5, 0, 3)],
 			true,
 			clBaseResource,
 			Math.round(fx + bbDist * Math.cos(bbAngle)),
 			Math.round(fz + bbDist * Math.sin(bbAngle))),
 		0);
 
 	// Create metal mine
 	let mAngle = bbAngle;
 	while (abs(mAngle - bbAngle) < PI/3)
 		mAngle = randFloat(0, 2 * PI);
 
 	let mDist = radius - 4;
 	createObjectGroup(
 		new SimpleGroup(
 			[new SimpleObject(oMetalLarge, 1, 1, 0, 0)],
 			true,
 			clBaseResource,
 			Math.round(fx + mDist * Math.cos(mAngle)),
 			Math.round(fz + mDist * Math.sin(mAngle))),
 		0);
 
 	// Create stone mine
 	mAngle += randFloat(PI/8, PI/4);
 	createObjectGroup(
 		new SimpleGroup(
 			[new SimpleObject(oStoneLarge, 1, 1, 0, 2)],
 			true,
 			clBaseResource,
 			Math.round(fx + mDist * Math.cos(mAngle)),
 			Math.round(fz + mDist * Math.sin(mAngle))),
 		0);
 
 	// Create starting trees
 	let hillSize = PI * radius * radius;
 	let num = Math.floor(hillSize / 100);
 	let tAngle = randFloat(-PI/3, 4 * PI/3);
 	let tDist = 12;
 	createObjectGroup(
 		new SimpleGroup(
 			[new SimpleObject(oBaobab, num, num, 0, 5)],
 			false,
 			clBaseResource,
 			Math.round(fx + tDist * Math.cos(tAngle)),
 			Math.round(fz + tDist * Math.sin(tAngle))),
 		0,
 		avoidClasses(clBaseResource, 2));
 
 	// Create grass tufts
 	num = hillSize / 250;
 	for (let j = 0; j < num; ++j)
 	{
 		let gAngle = randFloat(0, 2 * PI);
 		let gDist = radius - randIntInclusive(5, 11);
 		createObjectGroup(
 			new SimpleGroup(
 				[new SimpleObject(aGrassShort, 2, 5, 0, 1, -PI/8, PI/8)],
 				false,
 				clBaseResource,
 				Math.round(fx + gDist * Math.cos(gAngle)),
 				Math.round(fz + gDist * Math.sin(gAngle))),
 			0);
 	}
 }
 RMS.SetProgress(15);
 
 log("Creating bumps...");
 createAreas(
 	new ClumpPlacer(scaleByMapSize(20, 50), 0.6, 0.1, 1),
 	new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2),
 	avoidClasses(clPlayer, 13),
 	scaleByMapSize(300, 800));
 
 log("Creating hills...");
 createAreas(
 	new ChainPlacer(1, Math.floor(scaleByMapSize(4, 6)), Math.floor(scaleByMapSize(16, 40)), 0.5),
 	[
 		new LayeredPainter([tCliff, tHill], [2]),
 		new SmoothElevationPainter(ELEVATION_SET, 15, 2),
 		paintClass(clHill)
 	],
 	avoidClasses(clPlayer, 20, clHill, 15, clWater, 0),
 	scaleByMapSize(1, 4) * numPlayers * 3);
 
 log("Creating marshes...");
 for (let i = 0; i < 2; ++i)
 	createAreas(
 		new ChainPlacer(1, Math.floor(scaleByMapSize(6, 12)), Math.floor(scaleByMapSize(15, 60)), 0.8),
 		[
 			new LayeredPainter([tShoreBlend, tShore, tWater], [1, 1]),
 			new SmoothElevationPainter(ELEVATION_SET, -2, 3),
 			paintClass(clWater)
 		],
 		avoidClasses(clPlayer, 25, clWater, Math.round(scaleByMapSize(7, 16) * randFloat(0.8, 1.35))),
 		scaleByMapSize(4, 20));
 
 log("Creating reeds...");
 createObjectGroupsDeprecated(
 	new SimpleGroup(
 		[
 			new SimpleObject(aReeds, 20, 40, 0, 4),
 			new SimpleObject(aReeds2, 20, 40, 0, 4),
 			new SimpleObject(aLillies, 10, 30, 0, 4)
 		],
 		true),
 	0,
 	stayClasses(clWater, 1),
 	scaleByMapSize(400, 1000),
 	100);
 RMS.SetProgress(40);
 
 log("Creating bumps...");
 createAreas(
 	new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1),
 	new SmoothElevationPainter(ELEVATION_MODIFY, 1, 2),
 	stayClasses(clWater, 2),
 	scaleByMapSize(50, 100));
 
 log("Creating mud patches...");
 for (let size of [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)])
 	createAreas(
 		new ChainPlacer(2, Math.floor(scaleByMapSize(3, 6)), size, 1),
 		[
 			new LayeredPainter([tGrassA, tGrassB, tMud], [1, 1]),
 			paintClass(clDirt)
 		],
 		avoidClasses(clWater, 1, clHill, 0, clDirt, 5, clPlayer, 8),
 		scaleByMapSize(15, 45));
 RMS.SetProgress(50);
 
 log("Creating stone mines...");
 createObjectGroupsDeprecated(
 	new SimpleGroup(
 		[
 			new SimpleObject(oStoneSmall, 0, 2, 0, 4),
 			new SimpleObject(oStoneLarge, 1, 1, 0, 4)
 		],
 		true,
 		clRock),
 	0,
 	[avoidClasses(clWater, 0, clPlayer, 20, clRock, 10, clHill, 1)],
 	scaleByMapSize(4, 16),
 	100);
 
 createObjectGroupsDeprecated(
 	new SimpleGroup([new SimpleObject(oStoneSmall, 2, 5, 1, 3)], true, clRock),
 	0,
 	[avoidClasses(clWater, 0, clPlayer, 20, clRock, 10, clHill, 1)],
 	scaleByMapSize(4, 16),
 	100);
 
 log("Creating metal mines...");
 createObjectGroupsDeprecated(
 	new SimpleGroup([new SimpleObject(oMetalLarge, 1, 1, 0, 4)], true, clMetal),
 	0,
 	[avoidClasses(clWater, 0, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 1)],
 	scaleByMapSize(4, 16),
 	100);
 RMS.SetProgress(60);
 
 log("Creating small decorative rocks...");
 createObjectGroupsDeprecated(
 	new SimpleGroup([new SimpleObject(aRockMedium, 1, 3, 0, 1)], true),
 	0,
 	avoidClasses(clPlayer, 1),
 	scaleByMapSize(16, 262),
 	50);
 RMS.SetProgress(65);
 
 log("Creating large decorative rocks...");
 createObjectGroupsDeprecated(
 	new SimpleGroup(
 		[
 			new SimpleObject(aRockLarge, 1, 2, 0, 1),
 			new SimpleObject(aRockMedium, 1, 3, 0, 2)
 		],
 		true),
 	0,
 	avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0),
 	scaleByMapSize(8, 131),
 	50);
 RMS.SetProgress(70);
 
 log("Creating lions...");
 createObjectGroupsDeprecated(
 	new SimpleGroup(
 		[
 			new SimpleObject(oLion, 0, 1, 0, 4),
 			new SimpleObject(oLioness, 2, 3, 0, 4)
 		],
 		true,
 		clFood),
 	0,
 	avoidClasses(clWater, 1, clPlayer, 20, clFood, 11, clHill, 1),
 	scaleByMapSize(4, 12),
 	50);
 
 log("Creating zebras...");
 createObjectGroupsDeprecated(
 	new SimpleGroup(
 		[new SimpleObject(oZebra, 4, 6, 0, 4)],
 		true,
 		clFood),
 	0,
 	avoidClasses(clWater, 0, clForest, 0, clPlayer, 20, clHill, 1, clFood, 13),
 	3 * numPlayers,
 	50);
 
 log("Creating wildebeest...");
 createObjectGroupsDeprecated(
 	new SimpleGroup(
 		[new SimpleObject(oWildebeest, 2, 4, 0, 4)],
 		true,
 		clFood),
 	0,
 	avoidClasses(clWater, 0, clForest, 0, clPlayer, 20, clHill, 1, clFood, 13),
 	3 * numPlayers,
 	50);
 
 log("Creating crocodiles...");
 createObjectGroupsDeprecated(
 	new SimpleGroup(
 		[new SimpleObject(oCrocodile, 2, 3, 0, 4)],
 		true,
 		clFood),
 	0,
 	[avoidClasses(clForest, 0, clPlayer, 20, clHill, 1, clFood, 13), stayClasses(clWater, 3)],
 	5 * numPlayers,
 	200);
 
 log("Creating gazelles...");
 createObjectGroupsDeprecated(
 	new SimpleGroup(
 		[new SimpleObject(oGazelle, 4, 6, 0, 4)],
 		true,
 		clFood),
 	0,
 	avoidClasses(clWater, 0, clForest, 0, clPlayer, 20, clHill, 1, clFood, 13),
 	3 * numPlayers,
 	50);
 RMS.SetProgress(75);
 
 log("Creating rabbits...");
 createObjectGroupsDeprecated(
 	new SimpleGroup(
 		[new SimpleObject(oRabbit, 6, 8, 0, 2)],
 		true,
 		clFood),
 	0,
 	avoidClasses(clWater, 0, clForest, 0, clPlayer, 20, clHill, 1, clFood, 13),
 	6 * numPlayers,
 	50);
 
 log("Creating rhinos...");
 createObjectGroupsDeprecated(
 	new SimpleGroup(
 		[new SimpleObject(oRhino, 1, 1, 0, 2)],
 		true,
 		clFood),
 	0,
 	avoidClasses(clWater, 0, clForest, 0, clPlayer, 20, clHill, 1, clFood, 13),
 	3 * numPlayers,
 	50);
 
 log("Creating elephants...");
 createObjectGroupsDeprecated(
 	new SimpleGroup(
 		[new SimpleObject(oElephant, 2, 3, 0, 4), new SimpleObject(oElephantInfant, 1, 1, 0, 4)],
 		true,
 		clFood),
 	0,
 	avoidClasses(clWater, 0, clForest, 0, clPlayer, 20, clHill, 1, clFood, 13),
 	3 * numPlayers,
 	50);
 
 log("Creating berry bushes...");
 createObjectGroupsDeprecated(
 	new SimpleGroup(
 		[new SimpleObject(oBerryBush, 5, 7, 0, 4)],
 		true,
 		clFood),
 	0,
 	avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 10),
 	randIntInclusive(1, 4) * numPlayers + 2,
 	50);
 RMS.SetProgress(80);
 
 log("Creating straggler trees...");
 let treeTypes = [oToona, oBaobab, oBush, oBush];
 for (let treeType of treeTypes)
 	createObjectGroupsDeprecated(
 		new SimpleGroup(
 			[new SimpleObject(treeType, 1, 3, 0, 3)],
 			true,
 			clForest),
 		0,
 		avoidClasses(clForest, 1, clWater, 1, clHill, 1, clPlayer, 13, clMetal, 1, clRock, 1),
 		Math.floor(scaleByMapSize(60, 500) / treeTypes.length));
 RMS.SetProgress(85);
 
 log("Creating small grass tufts...");
 createObjectGroupsDeprecated(
 	new SimpleGroup([new SimpleObject(aGrassShort, 1, 2, 0, 1, -PI/8, PI/8)]),
 	0,
 	avoidClasses(clWater, 2, clPlayer, 13, clDirt, 0),
 	scaleByMapSize(13, 200));
 RMS.SetProgress(90);
 
 log("Creating large grass tufts...");
 createObjectGroupsDeprecated(
 	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)
 	]),
 	0,
 	avoidClasses(clWater, 3, clPlayer, 13, clDirt, 1, clForest, 0),
 	scaleByMapSize(13, 200));
 RMS.SetProgress(95);
 
 log("Creating bushes...");
 createObjectGroupsDeprecated(
 	new SimpleGroup(
 	[
 		new SimpleObject(aBushMedium, 1, 2, 0, 2),
 		new SimpleObject(aBushSmall, 2, 4, 0, 2)
 	]),
 	0,
 	avoidClasses(clWater, 1, clPlayer, 13, clDirt, 1),
 	scaleByMapSize(13, 200),
 	50);
 
 log("Creating flowering shrubs...");
 createObjectGroupsDeprecated(
 	new SimpleGroup([new SimpleObject(aShrub, 1, 1, 0, 2)]),
 	0,
 	avoidClasses(clWater, 1, clPlayer, 13, clDirt, 1),
 	scaleByMapSize(13, 200),
 	50);
 
 log("Creating decorative palms...");
 createObjectGroupsDeprecated(
 	new SimpleGroup([new SimpleObject(aPalm, 1, 3, 0, 2)]),
 	0,
 	avoidClasses(clWater, 2, clPlayer, 12, clDirt, 1),
 	scaleByMapSize(13, 200),
 	50);
 
 log("Creating shrubs,flowers and other decorations...");
 createObjectGroupsDeprecated(
 	new SimpleGroup(
 		[
 			new SimpleObject(aFlower, 0, 6, 0, 2),
 			new SimpleObject(aGrass2, 2, 5, 0, 2)
 		]),
 	0,
 	avoidClasses(clWater, 1, clHill, 1, clPlayer, 13, clDirt, 1),
 	scaleByMapSize(13, 200),
 	50);
 
 setSkySet("cirrus");
 setWaterColor(0.553, 0.635, 0.345);
 setWaterTint(0.161, 0.514, 0.635);
 setWaterMurkiness(0.8);
 setWaterWaviness(1.0);
 setWaterType("clap");
 
 setFogThickness(0.25);
 setFogFactor(0.6);
 
 setPPEffect("hdr");
 setPPSaturation(0.44);
 setPPBloom(0.3);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/cantabrian_highlands.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/cantabrian_highlands.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/cantabrian_highlands.js	(revision 20149)
@@ -1,340 +1,327 @@
 RMS.LoadLibrary("rmgen");
 
 const tGrass = ["temp_grass", "temp_grass", "temp_grass_d"];
 const tGrassPForest = "temp_plants_bog";
 const tGrassDForest = "temp_plants_bog";
 const tGrassA = "temp_grass_plants";
 const tGrassB = "temp_plants_bog";
 const tGrassC = "temp_mud_a";
 const tDirt = ["temp_plants_bog", "temp_mud_a"];
 const tHill = ["temp_highlands", "temp_grass_long_b"];
 const tCliff = ["temp_cliff_a", "temp_cliff_b"];
 const tRoad = "temp_road";
 const tRoadWild = "temp_road_overgrown";
 const tGrassPatchBlend = "temp_grass_long_b";
 const tGrassPatch = ["temp_grass_d", "temp_grass_clovers"];
 const tShoreBlend = "temp_grass_plants";
 const tShore = "temp_plants_bog";
 const tWater = "temp_mud_a";
 
 const oOak = "gaia/flora_tree_oak";
 const oOakLarge = "gaia/flora_tree_oak_large";
 const oApple = "gaia/flora_tree_apple";
 const oPine = "gaia/flora_tree_pine";
 const oAleppoPine = "gaia/flora_tree_aleppo_pine";
 const oBerryBush = "gaia/flora_bush_berry";
 const oDeer = "gaia/fauna_deer";
 const oFish = "gaia/fauna_fish";
 const oSheep = "gaia/fauna_sheep";
 const oStoneLarge = "gaia/geology_stonemine_temperate_quarry";
 const oStoneSmall = "gaia/geology_stone_temperate";
 const oMetalLarge = "gaia/geology_metal_temperate_slabs";
 
 const aGrass = "actor|props/flora/grass_soft_large_tall.xml";
 const aGrassShort = "actor|props/flora/grass_soft_large.xml";
 const aReeds = "actor|props/flora/reeds_pond_lush_a.xml";
 const aLillies = "actor|props/flora/pond_lillies_large.xml";
 const aRockLarge = "actor|geology/stone_granite_large.xml";
 const aRockMedium = "actor|geology/stone_granite_med.xml";
 const aBushMedium = "actor|props/flora/bush_medit_me.xml";
 const aBushSmall = "actor|props/flora/bush_medit_sm.xml";
 
 // terrain + entity (for painting)
 const pForestD = [tGrassDForest + TERRAIN_SEPARATOR + oOak, tGrassDForest + TERRAIN_SEPARATOR + oOakLarge, tGrassDForest];
 const pForestP = [tGrassPForest + TERRAIN_SEPARATOR + oPine, tGrassPForest + TERRAIN_SEPARATOR + oAleppoPine, tGrassPForest];
 
 InitMap();
 
 var numPlayers = getNumPlayers();
 var mapSize = getMapSize();
 var mapArea = mapSize*mapSize;
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clSettlement = createTileClass();
 
-var playerIDs = sortAllPlayers();
-
-// 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 [playerIDs, playerX, playerZ, playerAngle] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 
 	// calculate size based on the radius
 	var hillSize = PI * radius * radius;
 
 	// create the hill
 	var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 	var terrainPainter = new LayeredPainter(
 		[tCliff, tHill],		// terrains
 		[cliffRadius]		// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		elevation,				// elevation
 		cliffRadius				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clPlayer)], null);
 
 	// create the ramp
 	var rampAngle = playerAngle[i] + PI + randFloat(-PI/8, PI/8);
 	var rampDist = radius;
 	var rampLength = 15;
 	var rampWidth = 12;
 	var rampX1 = round(fx + (rampDist + rampLength) * cos(rampAngle));
 	var rampZ1 = round(fz + (rampDist + rampLength) * sin(rampAngle));
 	var rampX2 = round(fx + (rampDist - 3) * cos(rampAngle));
 	var rampZ2 = round(fz + (rampDist - 3) * sin(rampAngle));
 
 	createRamp (rampX1, rampZ1, rampX2, rampZ2, 3, 20, rampWidth, 2, tHill, tCliff, clPlayer);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tRoadWild, tRoad], [1]);
 	createArea(placer, painter, null);
 
 	placeCivDefaultEntities(fx, fz, id, { 'iberWall': false });
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oBerryBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 		mAngle = randFloat(0, TWO_PI);
 
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var num = 2;
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(11, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oOak, num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 RMS.SetProgress(10);
 
 log("Creating lakes...");
 var numLakes = round(scaleByMapSize(1,4) * numPlayers);
 placer = new ClumpPlacer(scaleByMapSize(100,250), 0.8, 0.1, 10);
 terrainPainter = new LayeredPainter(
 	[tShoreBlend, tShore, tWater],		// terrains
 	[1,1]							// widths
 );
 elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -7, 6);
 var waterAreas = createAreas(
 	placer,
 	[terrainPainter, elevationPainter, paintClass(clWater)],
 	avoidClasses(clPlayer, 2, clWater, 20),
 	numLakes
 );
 RMS.SetProgress(15);
 
 log("Creating reeds...");
 group = new SimpleGroup(
 	[new SimpleObject(aReeds, 5,10, 0,4), new SimpleObject(aLillies, 0,1, 0,4)], true
 );
 createObjectGroupsByAreasDeprecated(group, 0,
 	[borderClasses(clWater, 3, 0), stayClasses(clWater, 1)],
 	numLakes, 100,
 	waterAreas
 );
 RMS.SetProgress(20);
 
 log("Creating fish...");
 createObjectGroupsByAreasDeprecated(
 	new SimpleGroup(
 		[new SimpleObject(oFish, 1,1, 0,1)],
 		true, clFood
 	),
 	0,
 	[stayClasses(clWater, 4),  avoidClasses(clFood, 8)],
 	numLakes / 4,
 	50,
 	waterAreas
 );
 RMS.SetProgress(25);
 
 createBumps(avoidClasses(clWater, 2, clPlayer, 0));
 RMS.SetProgress(30);
 
 log("Creating hills...");
 createHills([tCliff, tCliff, tHill], avoidClasses(clPlayer, 2, clWater, 5, clHill, 15), clHill, scaleByMapSize(1, 4) * numPlayers);
 RMS.SetProgress(35);
 
 createForests(
  [tGrass, tGrassDForest, tGrassPForest, pForestP, pForestD],
  avoidClasses(clPlayer, 1, clWater, 3, clForest, 17, clHill, 1),
  clForest
 );
 RMS.SetProgress(40);
 
 log("Creating dirt patches...");
 createLayeredPatches(
  [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
  [[tGrass,tGrassA],[tGrassA,tGrassB], [tGrassB,tGrassC]],
  [1,1],
  avoidClasses(clWater, 1, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 0)
 );
 RMS.SetProgress(45);
 
 log("Creating grass patches...");
 createLayeredPatches(
  [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
  [tGrassPatchBlend, tGrassPatch],
  [1],
  avoidClasses(clWater, 1, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 0)
 );
 RMS.SetProgress(50);
 
 log("Creating stone mines...");
 createMines(
  [
   [new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)],
   [new SimpleObject(oStoneSmall, 2,5, 1,3)]
  ],
  avoidClasses(clWater, 0, clForest, 1, clPlayer, 5, clRock, 10, clHill, 1)
 );
 RMS.SetProgress(55);
 
 log("Creating metal mines...");
 createMines(
  [
   [new SimpleObject(oMetalLarge, 1,1, 0,4)]
  ],
  avoidClasses(clWater, 0, clForest, 1, clPlayer, 5, clMetal, 10, clRock, 5, clHill, 1),
  clMetal
 );
 RMS.SetProgress(60);
 
 createDecoration
 (
  [[new SimpleObject(aRockMedium, 1,3, 0,1)],
   [new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
   [new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)],
   [new SimpleObject(aGrass, 2,4, 0,1.8, -PI/8,PI/8), new SimpleObject(aGrassShort, 3,6, 1.2,2.5, -PI/8,PI/8)],
   [new SimpleObject(aBushMedium, 1,2, 0,2), new SimpleObject(aBushSmall, 2,4, 0,2)]
  ],
  [
   scaleByMapSize(16, 262),
   scaleByMapSize(8, 131),
   scaleByMapSize(13, 200),
   scaleByMapSize(13, 200),
   scaleByMapSize(13, 200)
  ],
  avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0)
 );
 RMS.SetProgress(70);
 
 createFood
 (
  [
   [new SimpleObject(oSheep, 2,3, 0,2)],
   [new SimpleObject(oDeer, 5,7, 0,4)]
  ],
  [
   3 * numPlayers,
   3 * numPlayers
  ],
  avoidClasses(clWater, 0, clForest, 0, clPlayer, 1, clHill, 1, clFood, 20)
 );
 RMS.SetProgress(80);
 
 createFood
 (
  [
   [new SimpleObject(oBerryBush, 5,7, 0,4)]
  ],
  [
   randIntInclusive(1, 4) * numPlayers + 2
  ],
  avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 10)
 );
 RMS.SetProgress(85);
 
 log("Creating metal mines...");
 var types = [oOak, oOakLarge, oPine, oApple];	// some variation
 createStragglerTrees(types, avoidClasses(clWater, 1, clForest, 1, clHill, 1, clPlayer, 1, clMetal, 6, clRock, 6));
 RMS.SetProgress(90);
 
 setSkySet("cirrus");
 setWaterColor(0.447, 0.412, 0.322);			// muddy brown
 setWaterTint(0.447, 0.412, 0.322);				// muddy brown
 setWaterMurkiness(1.0);
 setWaterWaviness(3.0);
 setWaterType("lake");
 
 setFogThickness(0.25);
 setFogFactor(0.4);
 
 setPPEffect("hdr");
 setPPSaturation(0.62);
 setPPContrast(0.62);
 setPPBloom(0.3);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/canyon.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/canyon.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/canyon.js	(revision 20149)
@@ -1,473 +1,461 @@
 RMS.LoadLibrary("rmgen");
 RMS.LoadLibrary("rmbiome");
 
 setSelectedBiome();
 
 const tMainTerrain = g_Terrains.mainTerrain;
 const tForestFloor1 = g_Terrains.forestFloor1;
 const tForestFloor2 = g_Terrains.forestFloor2;
 const tCliff = g_Terrains.cliff;
 const tTier1Terrain = g_Terrains.tier1Terrain;
 const tTier2Terrain = g_Terrains.tier2Terrain;
 const tTier3Terrain = g_Terrains.tier3Terrain;
 const tHill = g_Terrains.hill;
 const tDirt = g_Terrains.dirt;
 const tRoad = g_Terrains.road;
 const tRoadWild = g_Terrains.roadWild;
 const tTier4Terrain = g_Terrains.tier4Terrain;
 const tShoreBlend = g_Terrains.shoreBlend;
 const tShore = g_Terrains.shore;
 const tWater = g_Terrains.water;
 
 const oTree1 = g_Gaia.tree1;
 const oTree2 = g_Gaia.tree2;
 const oTree3 = g_Gaia.tree3;
 const oTree4 = g_Gaia.tree4;
 const oTree5 = g_Gaia.tree5;
 const oFruitBush = g_Gaia.fruitBush;
 const oMainHuntableAnimal = g_Gaia.mainHuntableAnimal;
 const oFish = g_Gaia.fish;
 const oSecondaryHuntableAnimal = g_Gaia.secondaryHuntableAnimal;
 const oStoneLarge = g_Gaia.stoneLarge;
 const oStoneSmall = g_Gaia.stoneSmall;
 const oMetalLarge = g_Gaia.metalLarge;
 const oWood = "gaia/special_treasure_wood";
 const oFood = "gaia/special_treasure_food_bin";
 
 const aGrass = g_Decoratives.grass;
 const aGrassShort = g_Decoratives.grassShort;
 const aReeds = g_Decoratives.reeds;
 const aLillies = g_Decoratives.lillies;
 const aRockLarge = g_Decoratives.rockLarge;
 const aRockMedium = g_Decoratives.rockMedium;
 const aBushMedium = g_Decoratives.bushMedium;
 const aBushSmall = g_Decoratives.bushSmall;
 const aTree = g_Decoratives.tree;
 
 const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
 const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
 
 InitMap();
 
 var numPlayers = getNumPlayers();
 var mapSize = getMapSize();
 var mapArea = mapSize*mapSize;
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clHill2 = createTileClass();
 var clForest = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clSettlement = createTileClass();
 var clLand = createTileClass();
 
 initTerrain(tMainTerrain);
 
 var fx = fractionToTiles(0.5);
 var fz = fractionToTiles(0.5);
 ix = round(fx);
 iz = round(fz);
 
 var lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 6))));
 
 var placer = new ClumpPlacer(mapArea * 0.065 * lSize, 0.7, 0.1, 10, ix, iz);
 var terrainPainter = new LayeredPainter(
 	[tMainTerrain, tMainTerrain],		// terrains
 	[3]		// widths
 );
 var elevationPainter = new SmoothElevationPainter(
 	ELEVATION_SET,			// type
 	3,				// elevation
 	3				// blend radius
 );
 createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
-var playerIDs = sortAllPlayers();
-
-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 [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(18,32);
 	var cliffRadius = 2;
 	var elevation = 20;
 	var hillSize = PI * radius * radius;
 	// get the x and z in tiles
 	fx = fractionToTiles(playerX[i]);
 	fz = fractionToTiles(playerZ[i]);
 	ix = round(fx);
 	iz = round(fz);
 	// create the hill
 	var placer = new ClumpPlacer(hillSize, 0.65, 0.1, 10, ix, iz);
 	var terrainPainter = new LayeredPainter(
 		[tMainTerrain, tMainTerrain],		// terrains
 		[cliffRadius]		// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		3,				// elevation
 		cliffRadius				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oFruitBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = 11;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 	var hillSize = PI * radius * radius;
 	// create starting trees
 	var num = floor(hillSize / 100);
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = 12;
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oTree1, num, num, 0,4)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 
 	// create the city patch
 	var cityRadius = radius/2;
 	placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, fractionToTiles(playerX[i]), fractionToTiles(playerZ[i]));
 	var painter = new LayeredPainter([tMainTerrain, tMainTerrain], [1]);
 	createArea(placer, [painter, paintClass(clPlayer)], null);
 
 }
 
 placer = new ClumpPlacer(150, 0.6, 0.3, 10, fractionToTiles(0.5), fractionToTiles(0.5));
 var painter = new LayeredPainter([tRoad, tRoad], [1]);
 createArea(placer, [painter, paintClass(clHill)], null);
 
 for (var i = 0; i < scaleByMapSize(9,16); i++)
 {
 	var placer = new PathPlacer(
 		randIntExclusive(1, mapSize),
 		randIntExclusive(1, mapSize),
 		randIntExclusive(1, mapSize),
 		randIntExclusive(1, mapSize),
 		scaleByMapSize(11,16),
 		0.4,
 		3 * scaleByMapSize(1,4),
 		0.1,
 		0);
 
 	var terrainPainter = new LayeredPainter(
 		[tMainTerrain, tMainTerrain],		// terrains
 		[3]		// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		30,				// elevation
 		3				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clHill2)], avoidClasses(clPlayer, 6, clHill2, 3, clHill, 2));
 }
 
 for (var g = 0; g < scaleByMapSize(5,30); g++)
 {
 	var tx = randIntInclusive(1, mapSize - 1);
 	var tz = randIntInclusive(1, mapSize - 1);
 
 	placer = new ClumpPlacer(mapArea * 0.01 * lSize, 0.7, 0.1, 10, tx, tz);
 	terrainPainter = new LayeredPainter(
 		[tMainTerrain, tMainTerrain],		// terrains
 		[3]		// widths
 	);
 	elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		3,				// elevation
 		3				// blend radius
 	);
 	var newarea = createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], avoidClasses(clLand, 6));
 	if (newarea !== null)
 	{
 		var distances = new Array(0);
 		var d1 = 9999;
 		var d2 = 9999;
 		var p1 = -1;
 		var p2 = 0;
 		for (var i = 0; i < numPlayers; i++)
 		{
 			distances.push(sqrt((tx-mapSize*playerX[i])*(tx-mapSize*playerX[i])+(tz-mapSize*playerZ[i])*(tz-mapSize*playerZ[i])));
 		}
 		for (var a = 0; a < numPlayers; a++)
 		{
 			if (d1 >= distances[a])
 			{
 				d2 = d1;
 				d1 = distances[a];
 				p2 = p1;
 				p1 = a;
 			}
 			else if (d2 >= distances[a])
 			{
 				d2 = distances[a];
 				p2 = a;
 			}
 		}
 
 		var placer = new PathPlacer(tx, tz, mapSize*playerX[p1], mapSize*playerZ[p1], scaleByMapSize(11,17), 0.4, 3*(scaleByMapSize(1,4)), 0.1, 0.1);
 		var terrainPainter = new LayeredPainter(
 			[tMainTerrain, tMainTerrain],		// terrains
 			[3]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			3,				// elevation
 			3				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 		if (numPlayers > 1)
 		{
 			var placer = new PathPlacer(tx, tz, mapSize*playerX[p2], mapSize*playerZ[p2], scaleByMapSize(11,17), 0.4, 3*(scaleByMapSize(1,4)), 0.1, 0.1);
 			var terrainPainter = new LayeredPainter(
 				[tMainTerrain, tMainTerrain],		// terrains
 				[3]		// widths
 			);
 			var elevationPainter = new SmoothElevationPainter(
 				ELEVATION_SET,			// type
 				3,				// elevation
 				3				// blend radius
 			);
 			createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 	}
 }
 
 for (var i = 0; i < numPlayers; i++)
 {
 	if (i+1 == numPlayers)
 	{
 		var placer = new PathPlacer(fractionToTiles(playerX[i]), fractionToTiles(playerZ[i]), fractionToTiles(playerX[0]), fractionToTiles(playerZ[0]), scaleByMapSize(8,13), 0.4, 3*(scaleByMapSize(1,4)), 0.1, 0);
 	}
 	else
 	{
 		var placer = new PathPlacer(fractionToTiles(playerX[i]), fractionToTiles(playerZ[i]), fractionToTiles(playerX[i+1]), fractionToTiles(playerZ[i+1]), scaleByMapSize(8,13), 0.4, 3*(scaleByMapSize(1,4)), 0.1, 0);
 	}
 	var terrainPainter = new LayeredPainter(
 		[tRoadWild, tRoad],		// terrains
 		[1]		// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		3,				// elevation
 		2				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand), paintClass(clHill)], null);
 
 	var placer = new PathPlacer(fractionToTiles(playerX[i]), fractionToTiles(playerZ[i]), fractionToTiles(0.5), fractionToTiles(0.5), scaleByMapSize(8,13), 0.4, 3*(scaleByMapSize(1,4)), 0.1, 0);
 	var terrainPainter = new LayeredPainter(
 		[tRoadWild, tRoad],		// terrains
 		[1]		// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		3,				// elevation
 		2				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand), paintClass(clHill)], null);
 
 }
 
 for (var i = 0; i < numPlayers; i++)
 {
 	// create the city patch
 	var cityRadius = radius/3;
 	placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, fractionToTiles(playerX[i]), fractionToTiles(playerZ[i]));
 	var painter = new LayeredPainter([tRoad, tRoad], [1]);
 	createArea(placer, [painter, paintClass(clPlayer)], null);
 }
 
 placer = new ClumpPlacer(150, 0.6, 0.3, 10, fractionToTiles(0.5), fractionToTiles(0.5));
 var painter = new LayeredPainter([tRoad, tRoad], [1]);
 createArea(placer, [painter, paintClass(clHill)], null);
 
 RMS.SetProgress(20);
 
 paintTerrainBasedOnHeight(3.1, 29, 0, tCliff);
 paintTileClassBasedOnHeight(3.1, 32, 0, clHill2);
 
 createBumps([avoidClasses(clPlayer, 2), stayClasses(clLand, 2)]);
 
 createHills([tCliff, tCliff, tHill], [avoidClasses(clPlayer, 2, clHill, 8, clHill2, 8), stayClasses(clLand, 5)], clHill, scaleByMapSize(10, 40));
 
 // create hills outside the canyon
 createHills([tCliff, tCliff, tMainTerrain], avoidClasses(clLand, 1, clHill, 1), clHill, scaleByMapSize(20, 150), undefined, undefined, undefined, undefined, 40);
 
 createForests(
  [tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
  [avoidClasses(clPlayer, 1, clForest, 15, clHill, 1, clHill2, 0), stayClasses(clLand, 4)],
  clForest,
  1,
  ...rBiomeTreeCount(1)
 );
 
 RMS.SetProgress(50);
 
 log("Creating dirt patches...");
 createLayeredPatches(
  [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
  [[tMainTerrain,tTier1Terrain],[tTier1Terrain,tTier2Terrain], [tTier2Terrain,tTier3Terrain]],
  [1,1],
  [avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 4, clHill2, 0), stayClasses(clLand, 3)]
 );
 
 log("Creating grass patches...");
 createPatches(
  [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
  tTier4Terrain,
  [avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 4, clHill2, 0), stayClasses(clLand, 3)]
 );
 
 log("Creating stone mines...");
 createMines(
  [
   [new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)],
   [new SimpleObject(oStoneSmall, 2,5, 1,3)]
  ],
  [avoidClasses(clForest, 1, clPlayer, 3, clRock, 10, clHill, 1, clHill2, 1), stayClasses(clLand, 2)]
 );
 
 log("Creating metal mines...");
 createMines(
  [
   [new SimpleObject(oMetalLarge, 1,1, 0,4)]
  ],
  [avoidClasses(clForest, 1, clPlayer, 3, clMetal, 10, clRock, 5, clHill, 1, clHill2, 1), stayClasses(clLand, 2)],
  clMetal
 );
 
 RMS.SetProgress(65);
 
 var planetm = 1;
 
 if (currentBiome() == "tropic")
 	planetm = 8;
 
 createDecoration
 (
  [[new SimpleObject(aRockMedium, 1,3, 0,1)],
   [new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
   [new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)],
   [new SimpleObject(aGrass, 2,4, 0,1.8, -PI/8,PI/8), new SimpleObject(aGrassShort, 3,6, 1.2,2.5, -PI/8,PI/8)],
   [new SimpleObject(aBushMedium, 1,2, 0,2), new SimpleObject(aBushSmall, 2,4, 0,2)]
  ],
  [
   3*scaleByMapSize(16, 262),
   3*scaleByMapSize(8, 131),
   planetm * scaleByMapSize(13, 200),
   planetm * scaleByMapSize(13, 200),
   planetm * scaleByMapSize(13, 200)
  ],
  avoidClasses(clForest, 0, clPlayer, 0, clHill, 0)
 );
 
 log("Creating actor trees...");
 group = new SimpleGroup(
 	[new SimpleObject(aTree, 1,1, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clLand, 5),
 	scaleByMapSize(200, 800), 50
 );
 
 RMS.SetProgress(70);
 
 createFood
 (
  [
   [new SimpleObject(oMainHuntableAnimal, 5,7, 0,4)],
   [new SimpleObject(oSecondaryHuntableAnimal, 2,3, 0,2)]
  ],
  [
   3 * numPlayers,
   3 * numPlayers
  ],
  [avoidClasses(clForest, 0, clPlayer, 4, clHill, 1, clFood, 20, clHill2, 1), stayClasses(clLand, 3)]
 );
 
 createFood
 (
  [
   [new SimpleObject(oFruitBush, 5,7, 0,4)]
  ],
  [
   3 * numPlayers
  ],
  [avoidClasses(clForest, 0, clPlayer, 4, clHill, 1, clFood, 10, clHill2, 1), stayClasses(clLand, 3)]
 );
 
 RMS.SetProgress(85);
 
 log("Creating straggler trees...");
 var types = [oTree1, oTree2, oTree4, oTree3];	// some variation
 createStragglerTrees(types, [avoidClasses(clForest, 1, clHill, 1, clPlayer, 9, clMetal, 6, clRock, 6, clHill2, 1), stayClasses(clLand, 3)]);
 
 log("Creating treasures...");
 var fx = fractionToTiles(0.5);
 var fz = fractionToTiles(0.5);
 for (let i = 0; i < randIntInclusive(3, 8); ++i)
 	placeObject(fx + randFloat(-7, 7), fz + randFloat(-7, 7), oWood, 0, randFloat(0, 2 * PI));
 
 for (let i = 0; i < randIntInclusive(3, 8); ++i)
 	placeObject(fx + randFloat(-7, 7), fz + randFloat(-7, 7), oFood, 0, randFloat(0, 2 * PI));
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/continent.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/continent.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/continent.js	(revision 20149)
@@ -1,322 +1,310 @@
 RMS.LoadLibrary("rmgen");
 RMS.LoadLibrary("rmbiome");
 
 setSelectedBiome();
 
 const tMainTerrain = g_Terrains.mainTerrain;
 const tForestFloor1 = g_Terrains.forestFloor1;
 const tForestFloor2 = g_Terrains.forestFloor2;
 const tCliff = g_Terrains.cliff;
 const tTier1Terrain = g_Terrains.tier1Terrain;
 const tTier2Terrain = g_Terrains.tier2Terrain;
 const tTier3Terrain = g_Terrains.tier3Terrain;
 const tHill = g_Terrains.hill;
 const tDirt = g_Terrains.dirt;
 const tRoad = g_Terrains.road;
 const tRoadWild = g_Terrains.roadWild;
 const tTier4Terrain = g_Terrains.tier4Terrain;
 const tShoreBlend = g_Terrains.shoreBlend;
 const tShore = g_Terrains.shore;
 const tWater = g_Terrains.water;
 
 const oTree1 = g_Gaia.tree1;
 const oTree2 = g_Gaia.tree2;
 const oTree3 = g_Gaia.tree3;
 const oTree4 = g_Gaia.tree4;
 const oTree5 = g_Gaia.tree5;
 const oFruitBush = g_Gaia.fruitBush;
 const oMainHuntableAnimal = g_Gaia.mainHuntableAnimal;
 const oFish = g_Gaia.fish;
 const oSecondaryHuntableAnimal = g_Gaia.secondaryHuntableAnimal;
 const oStoneLarge = g_Gaia.stoneLarge;
 const oStoneSmall = g_Gaia.stoneSmall;
 const oMetalLarge = g_Gaia.metalLarge;
 
 const aGrass = g_Decoratives.grass;
 const aGrassShort = g_Decoratives.grassShort;
 const aReeds = g_Decoratives.reeds;
 const aLillies = g_Decoratives.lillies;
 const aRockLarge = g_Decoratives.rockLarge;
 const aRockMedium = g_Decoratives.rockMedium;
 const aBushMedium = g_Decoratives.bushMedium;
 const aBushSmall = g_Decoratives.bushSmall;
 
 const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
 const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
 
 InitMap();
 
 var numPlayers = getNumPlayers();
 var mapSize = getMapSize();
 var mapArea = mapSize*mapSize;
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clSettlement = createTileClass();
 var clLand = createTileClass();
 
 initTerrain(tWater);
 
 var fx = fractionToTiles(0.5);
 var fz = fractionToTiles(0.5);
 ix = round(fx);
 iz = round(fz);
 
 var placer = new ChainPlacer(2, floor(scaleByMapSize(5, 12)), floor(scaleByMapSize(60, 700)), 1, ix, iz, 0, [floor(mapSize * 0.33)]);
 var terrainPainter = new LayeredPainter(
 	[tMainTerrain, tMainTerrain],		// terrains
 	[3]		// widths
 );
 var elevationPainter = new SmoothElevationPainter(
 	ELEVATION_SET,			// type
 	3,				// elevation
 	4				// blend radius
 );
 createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
-var playerIDs = sortAllPlayers();
-
-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 [playerIDs, playerX, playerZ] = radialPlayerPlacement(0.25);
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	fx = fractionToTiles(playerX[i]);
 	fz = fractionToTiles(playerZ[i]);
 	ix = round(fx);
 	iz = round(fz);
 	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);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oFruitBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var num = 2;
 	var tAngle = randFloat(0, TWO_PI);
 	var tDist = randFloat(12, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oTree1, num, num, 0,3)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 
 RMS.SetProgress(20);
 
 paintTerrainBasedOnHeight(3, 4, 3, tMainTerrain);
 paintTerrainBasedOnHeight(1, 3, 0, tShore);
 paintTerrainBasedOnHeight(-8, 1, 2, tWater);
 
 for (var i = 0; i < numPlayers; ++i)
 {
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	var placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tRoadWild, tRoad], [1]);
 	createArea(placer, painter, null);
 }
 
 createBumps([avoidClasses(clPlayer, 10), stayClasses(clLand, 5)]);
 
 if (randBool())
 	createHills([tMainTerrain, tCliff, tHill], [avoidClasses(clPlayer, 20, clHill, 15, clBaseResource, 3), stayClasses(clLand, 5)], clHill, scaleByMapSize(1, 4) * numPlayers);
 else
 	createMountains(tCliff, [avoidClasses(clPlayer, 20, clHill, 15, clBaseResource, 3), stayClasses(clLand, 5)], clHill, scaleByMapSize(1, 4) * numPlayers);
 
 createForests(
  [tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
  [avoidClasses(clPlayer, 20, clForest, 17, clHill, 0, clBaseResource,2), stayClasses(clLand, 4)],
  clForest,
  1.0,
  ...rBiomeTreeCount(1));
 
 RMS.SetProgress(50);
 
 log("Creating dirt patches...");
 createLayeredPatches(
  [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
  [[tMainTerrain,tTier1Terrain],[tTier1Terrain,tTier2Terrain], [tTier2Terrain,tTier3Terrain]],
  [1,1],
  [avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12), stayClasses(clLand, 5)]
 );
 
 log("Creating grass patches...");
 createPatches(
  [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
  tTier4Terrain,
  [avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12), stayClasses(clLand, 5)]
 );
 
 RMS.SetProgress(55);
 
 log("Creating stone mines...");
 createMines(
  [
   [new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)],
   [new SimpleObject(oStoneSmall, 2,5, 1,3)]
  ],
  [avoidClasses(clForest, 1, clPlayer, 20, clRock, 10, clHill, 1), stayClasses(clLand, 6)]
 );
 
 log("Creating metal mines...");
 createMines(
  [
   [new SimpleObject(oMetalLarge, 1,1, 0,4)]
  ],
  [avoidClasses(clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 1), stayClasses(clLand, 6)],
  clMetal
 );
 
 RMS.SetProgress(65);
 
 // create decoration
 var planetm = 1;
 
 if (currentBiome() == "tropic")
 	planetm = 8;
 
 createDecoration
 (
  [[new SimpleObject(aRockMedium, 1,3, 0,1)],
   [new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
   [new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)],
   [new SimpleObject(aGrass, 2,4, 0,1.8, -PI/8,PI/8), new SimpleObject(aGrassShort, 3,6, 1.2,2.5, -PI/8,PI/8)],
   [new SimpleObject(aBushMedium, 1,2, 0,2), new SimpleObject(aBushSmall, 2,4, 0,2)]
  ],
  [
   scaleByMapSize(16, 262),
   scaleByMapSize(8, 131),
   planetm * scaleByMapSize(13, 200),
   planetm * scaleByMapSize(13, 200),
   planetm * scaleByMapSize(13, 200)
  ],
  [avoidClasses(clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 5)]
 );
 
 RMS.SetProgress(70);
 
 createFood
 (
  [
   [new SimpleObject(oMainHuntableAnimal, 5,7, 0,4)],
   [new SimpleObject(oSecondaryHuntableAnimal, 2,3, 0,2)]
  ],
  [
   3 * numPlayers,
   3 * numPlayers
  ],
  [avoidClasses(clForest, 0, clPlayer, 20, clHill, 1, clFood, 20), stayClasses(clLand, 5)]
 );
 
 createFood
 (
  [
   [new SimpleObject(oFruitBush, 5,7, 0,4)]
  ],
  [
   3 * numPlayers
  ],
  [avoidClasses(clForest, 0, clPlayer, 20, clHill, 1, clFood, 10), stayClasses(clLand, 5)]
 );
 
 createFood
 (
  [
   [new SimpleObject(oFish, 2,3, 0,2)]
  ],
  [
   25 * numPlayers
  ],
  avoidClasses(clLand, 2, clFood, 20)
 );
 
 RMS.SetProgress(85);
 
 log("Creating straggler trees...");
 var types = [oTree1, oTree2, oTree4, oTree3];	// some variation
 createStragglerTrees(types, [avoidClasses(clForest, 7, clHill, 1, clPlayer, 9, clMetal, 6, clRock, 6), stayClasses(clLand, 7)]);
 setWaterWaviness(1.0);
 setWaterType("ocean");
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/extinct_volcano.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/extinct_volcano.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/extinct_volcano.js	(revision 20149)
@@ -1,520 +1,514 @@
 RMS.LoadLibrary("rmgen");
 
 const tHillDark = "cliff volcanic light";
 const tHillMedium1 = "ocean_rock_a";
 const tHillMedium2 = "ocean_rock_b";
 const tHillVeryDark = ["cliff volcanic coarse", "cave_walls"];
 const tRoad = "road1";
 const tRoadWild = "road1";
 const tForestFloor1 = tHillMedium1;
 const tForestFloor2 = tHillMedium2;
 const tGrassA = "cliff volcanic light";
 const tGrassB = "ocean_rock_a";
 const tGrass3 = "temp_grass_plants";
 const tGrassPatchBlend = "temp_grass_long_b";
 const tGrassPatch = ["temp_grass_d", "temp_grass_clovers"];
 const tShoreBlend = "cliff volcanic light";
 const tShore = "ocean_rock_a";
 const tWater = "ocean_rock_b";
 
 // Gaia entities
 const oTree = "gaia/flora_tree_dead";
 const oTree2 = "gaia/flora_tree_euro_beech";
 const oTree3 = "gaia/flora_tree_oak";
 const oTree4 = "gaia/flora_tree_oak_dead";
 const oBush = "gaia/flora_bush_temperate";
 const oFruitBush = "gaia/flora_bush_berry";
 const oRabbit = "gaia/fauna_rabbit";
 const oGoat = "gaia/fauna_goat";
 const oBear = "gaia/fauna_bear";
 const oStoneLarge = "gaia/geology_stonemine_temperate_quarry";
 const oStoneSmall = "gaia/geology_stone_temperate";
 const oMetalLarge = "gaia/geology_metal_temperate_slabs";
 const oTower = "other/palisades_rocks_fort";
 
 // Decorative props
 const aRockLarge = "actor|geology/stone_granite_med.xml";
 const aRockMedium = "actor|geology/stone_granite_med.xml";
 const aBushMedium = "actor|props/flora/bush_tempe_me.xml";
 const aBushSmall = "actor|props/flora/bush_tempe_sm.xml";
 const aGrass = "actor|props/flora/grass_soft_large_tall.xml";
 const aGrassShort = "actor|props/flora/grass_soft_large.xml";
 const aRain = "actor|particle/rain_shower.xml";
 
 const pForestD = [
 	tForestFloor1 + TERRAIN_SEPARATOR + oTree,
 	tForestFloor2 + TERRAIN_SEPARATOR + oTree2,
 	tForestFloor1
 ];
 
 const pForestP = [
 	tForestFloor1 + TERRAIN_SEPARATOR + oTree3,
 	tForestFloor2 + TERRAIN_SEPARATOR + oTree4,
 	tForestFloor1
 ];
 
 InitMap();
 
 var P_FOREST = 0.7;
 var totalTrees = scaleByMapSize(1200, 3000);
 var numForest = totalTrees * P_FOREST;
 var numStragglers = totalTrees * (1.0 - P_FOREST);
 
 var numPlayers = getNumPlayers();
 var mapSize = getMapSize();
 var mapArea = mapSize * mapSize;
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clFood = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clGrass = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clBaseResource = createTileClass();
 var clBumps = createTileClass();
 var clTower = createTileClass();
 var clRain = createTileClass();
 
 var ccMountainHeight = 25;
 
-var playerIDs = sortAllPlayers();
+var [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
-// Place players
-var startAngle = randFloat(0, 2 * PI);
 for (let i = 0; i < numPlayers; ++i)
 {
-	let playerAngle = startAngle + i * 2 * PI / numPlayers;
-	let playerX = 0.5 + 0.35 * Math.cos(playerAngle);
-	let playerZ = 0.5 + 0.35 * Math.sin(playerAngle);
-
 	let id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 	let radius = scaleByMapSize(15, 25);
 
-	let fx = fractionToTiles(playerX);
-	let fz = fractionToTiles(playerZ);
+	let fx = fractionToTiles(playerX[i]);
+	let fz = fractionToTiles(playerZ[i]);
 	let ix = Math.round(fx);
 	let iz = Math.round(fz);
 
 	// This one consists of many bumps, creating an omnidirectional ramp
 	createMountain(
 		ccMountainHeight,
 		Math.floor(scaleByMapSize(15, 15)),
 		Math.floor(scaleByMapSize(15, 15)),
 		Math.floor(scaleByMapSize(4, 10)),
 		avoidClasses(),
 		ix,
 		iz,
 		tHillDark,
 		clPlayer,
 		14);
 
 	// Flatten the initial CC area
 	let hillSize = PI * radius * radius;
 	createArea(
 		new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz),
 		[
 			new LayeredPainter([tHillVeryDark, tHillMedium1], [radius]),
 			new SmoothElevationPainter(ELEVATION_SET, ccMountainHeight, radius),
 			paintClass(clPlayer)
 		],
 		null);
 
 	// Create the city patch
 	let cityRadius = radius / 3;
 	createArea(
 		new ClumpPlacer(PI * cityRadius * cityRadius, 0.6, 0.3, 10, ix, iz),
 		new LayeredPainter([tRoadWild, tRoad], [1]),
 		null);
 
 	placeCivDefaultEntities(fx, fz, id, { 'iberWall': 'towers' });
 
 	// Create metal mine
 	let mAngle = randFloat(0, 2 * PI);
 	let mDist = 12;
 	createObjectGroup(
 		new SimpleGroup(
 			[new SimpleObject(oMetalLarge, 1, 1, 0, 0)],
 			true,
 			clBaseResource,
 			Math.round(fx + mDist * Math.cos(mAngle)),
 			Math.round(fz + mDist * Math.sin(mAngle))),
 		0);
 
 	// Create stone mines
 	mAngle += randFloat(PI/4, PI/3);
 	createObjectGroup(
 		new SimpleGroup(
 			[new SimpleObject(oStoneLarge, 1, 1, 0, 2)],
 			true,
 			clBaseResource,
 			Math.round(fx + mDist * Math.cos(mAngle)),
 			Math.round(fz + mDist * Math.sin(mAngle))),
 		0);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// Create berry bushes
 	mAngle += randFloat(PI/4, PI/2);
 	let bbDist = 12;
 	createObjectGroup(
 		new SimpleGroup(
 			[new SimpleObject(oFruitBush, 5, 5, 0, 3)],
 			true,
 			clBaseResource,
 			Math.round(fx + bbDist * Math.cos(mAngle)),
 			Math.round(fz + bbDist * Math.sin(mAngle))),
 		0);
 
 	// Create starting trees
 	let num = Math.floor(hillSize / 60);
 	let tries = 20;
 	for (let x = 0; x < tries; ++x)
 	{
 		let tAngle = randFloat(0, 2 * PI);
 		let tDist = randFloat(10, 12);
 		if (createObjectGroup(
 			new SimpleGroup(
 				[new SimpleObject(oTree2, num, num, 0, 3)],
 				false,
 				clBaseResource,
 				Math.round(fx + tDist * Math.cos(tAngle)),
 				Math.round(fz + tDist * Math.sin(tAngle))),
 			0,
 			avoidClasses(clBaseResource, 3)))
 		{
 			break;
 		}
 	}
 }
 RMS.SetProgress(15);
 
 createVolcano(0.5, 0.5, clHill, tHillVeryDark, undefined, false, ELEVATION_SET);
 RMS.SetProgress(20);
 
 log("Creating lakes...");
 createAreas(
 	new ChainPlacer(5, 6, Math.floor(scaleByMapSize(10, 14)), 0.1),
 	[
 		new LayeredPainter([tShoreBlend, tShore, tWater], [1, 1]),
 		new SmoothElevationPainter(ELEVATION_SET, -4, 3),
 		paintClass(clWater)
 	],
 	avoidClasses(clPlayer, 0, clHill, 2, clWater, 12),
 	Math.round(scaleByMapSize(6, 12)));
 RMS.SetProgress(25);
 
 createBumps(avoidClasses(clPlayer, 0, clHill, 0), scaleByMapSize(50, 300), 1, 10, 3, 0, scaleByMapSize(4, 10));
 paintTileClassBasedOnHeight(10, 100, 0, clBumps);
 RMS.SetProgress(30);
 
 log("Creating hills...");
 createAreas(
 	new ClumpPlacer(scaleByMapSize(20, 150), 0.2, 0.1, 1),
 	[
 		new LayeredPainter([tHillDark, tHillDark, tHillDark], [2, 2]),
 		new SmoothElevationPainter(ELEVATION_SET, 18, 2),
 		paintClass(clHill)
 	],
 	avoidClasses(clPlayer, 0, clHill, 15, clWater, 2, clBaseResource, 2),
 	scaleByMapSize(2, 8) * numPlayers);
 RMS.SetProgress(35);
 
 log("Creating forests...");
 var types = [
 	[[tGrassB, tGrassA, pForestD], [tGrassB, pForestD]],
 	[[tGrassB, tGrassA, pForestP], [tGrassB, pForestP]]
 ];
 var size = numForest / (scaleByMapSize(4, 12) * numPlayers);
 var num = Math.floor(size / types.length);
 for (let i = 0; i < types.length; ++i)
 	createAreas(
 		new ClumpPlacer(numForest / num, 0.1, 0.1, 1),
 		[
 			new LayeredPainter(types[i], [2]),
 			paintClass(clForest)
 		],
 		avoidClasses(
 			clPlayer, 4,
 			clForest, 10,
 			clHill, 0,
 			clWater, 2),
 		num);
 RMS.SetProgress(40);
 
 log("Creating hill patches...");
 for (let size of [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)])
 	for (let type of [[tHillMedium1, tHillDark], [tHillDark, tHillMedium2], [tHillMedium1, tHillMedium2]])
 		createAreas(
 			new ClumpPlacer(size, 0.3, 0.06, 0.5),
 			[
 				new LayeredPainter(type, [1]),
 				paintClass(clGrass)
 			],
 			avoidClasses(
 				clWater, 3,
 				clForest, 0,
 				clHill, 0,
 				clBumps, 0,
 				clPlayer, 0),
 			scaleByMapSize(20, 80));
 RMS.SetProgress(45);
 
 log("Creating grass patches...");
 createLayeredPatches(
 	[scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
 	[tGrassPatchBlend, tGrassPatch],
 	[1],
 	avoidClasses(
 		clWater, 1,
 		clForest, 0,
 		clHill, 0,
 		clGrass, 5,
 		clBumps, 0,
 		clPlayer, 0),
 	clDirt);
 RMS.SetProgress(50);
 
 log("Creating stone mines...");
 createObjectGroupsDeprecated(
 	new SimpleGroup(
 		[
 			new SimpleObject(oStoneSmall, 0, 2, 0, 4),
 			new SimpleObject(oStoneLarge, 1, 1, 0, 4)
 		],
 		true,
 		clRock),
 	0,
 	[
 		stayClasses(clBumps, 1),
 		avoidClasses(
 			clWater, 3,
 			clForest, 1,
 			clPlayer, 0,
 			clRock, 15,
 			clHill, 0)
 	],
 	100,
 	100);
 RMS.SetProgress(55);
 
 log("Creating small stone quarries...");
 createObjectGroupsDeprecated(
 	new SimpleGroup([new SimpleObject(oStoneSmall, 2, 5, 1, 3)], true, clRock),
 	0,
 	[
 		stayClasses(clBumps, 1),
 		avoidClasses(
 			clWater, 3,
 			clForest, 1,
 			clPlayer, 0,
 			clRock, 15,
 			clHill, 0)
 	],
 	100,
 	100);
 RMS.SetProgress(60);
 
 log("Creating metal mines...");
 createObjectGroupsDeprecated(
 	new SimpleGroup([new SimpleObject(oMetalLarge, 1, 1, 0, 4)], true, clMetal),
 	0,
 	[
 		stayClasses(clBumps, 1),
 		avoidClasses(
 			clWater, 3,
 			clForest, 1,
 			clPlayer, 0,
 			clMetal, 15,
 			clRock, 10,
 			clHill, 0)
 	],
 	100,
 	100);
 RMS.SetProgress(65);
 
 log("Creating towers...");
 createObjectGroupsDeprecated(
 	new SimpleGroup([new SimpleObject(oTower, 1, 1, 0, 4)], true, clTower),
 	0,
 	[
 		stayClasses(clBumps, 3),
 		avoidClasses(
 			clMetal, 5,
 			clRock, 5,
 			clHill, 0,
 			clTower, 60,
 			clPlayer, 10,
 			clForest, 2)
 	],
 	500,
 	1);
 RMS.SetProgress(67);
 
 createDecoration(
 		[
 			[new SimpleObject(aGrassShort, 1, 2, 0, 1)],
 			[
 				new SimpleObject(aGrass, 2, 4, 0, 1.8),
 				new SimpleObject(aGrassShort, 3, 6, 1.2, 2.5)
 			],
 			[
 				new SimpleObject(aBushMedium, 1, 2, 0, 2),
 				new SimpleObject(aBushSmall, 2, 4, 0, 2)
 			]
 		],
 		[
 			scaleByMapSize(15, 200),
 			scaleByMapSize(15, 200),
 			scaleByMapSize(15, 200)
 		],
 		[
 			stayClasses(clGrass, 0),
 			avoidClasses(
 				clWater, 0,
 				clForest, 0,
 				clPlayer, 0,
 				clHill, 0)
 		]);
 RMS.SetProgress(70);
 
 createDecoration(
 		[
 			[
 				new SimpleObject(aRockMedium, 1, 3, 0, 1)
 			],
 			[
 				new SimpleObject(aRockLarge, 1, 2, 0, 1),
 				new SimpleObject(aRockMedium, 1, 3, 0, 2)
 			]
 		],
 		[
 			scaleByMapSize(15, 250),
 			scaleByMapSize(15, 150)
 		],
 		avoidClasses(
 			clWater, 0,
 			clForest, 0,
 			clPlayer, 0,
 			clHill, 0
 		));
 RMS.SetProgress(75);
 
 createFood(
 	[
 		[new SimpleObject(oRabbit, 5, 7, 2, 4)],
 		[new SimpleObject(oGoat, 3, 5, 2, 4)]
 	],
 	[
 		scaleByMapSize(1, 6) * numPlayers,
 		scaleByMapSize(3, 10) * numPlayers
 	],
 	[
 		avoidClasses(
 			clWater, 1,
 			clForest, 0,
 			clPlayer, 0,
 			clHill, 1,
 			clFood, 20)
 	],
 	clFood);
 RMS.SetProgress(78);
 
 createFood(
 	[
 		[new SimpleObject(oBear, 1, 1, 0, 2)]
 	],
 	[
 		3 * numPlayers
 	],
 	[
 		avoidClasses(
 			clWater, 1,
 			clForest, 0,
 			clPlayer, 0,
 			clHill, 1,
 			clFood, 20
 		),
 		stayClasses(clForest, 2)
 	],
 	clFood);
 RMS.SetProgress(81);
 
 createFood(
 	[
 		[new SimpleObject(oFruitBush, 1, 2, 0, 4)]
 	],
 	[
 		3 * numPlayers
 	],
 	[stayClasses(clGrass, 1), avoidClasses(clWater, 1, clForest, 0, clPlayer, 0, clHill, 1, clFood, 10)],
 	clFood);
 RMS.SetProgress(85);
 
 log("Creating straggler trees and bushes...");
 var types = [oTree, oTree2, oTree3, oTree4, oBush];
 var num = Math.floor(numStragglers / types.length);
 for (let type of types)
 	createObjectGroupsDeprecated(
 		new SimpleGroup(
 			[new SimpleObject(type, 1, 1, 0, 3)],
 			true,
 			clForest),
 		0,
 		[
 			stayClasses(clGrass, 1),
 			avoidClasses(
 				clWater, 5,
 				clForest, 1,
 				clHill, 1,
 				clPlayer, 0,
 				clMetal, 1,
 				clRock, 1)
 		],
 		num);
 RMS.SetProgress(90);
 
 log("Creating straggler bushes...");
 createObjectGroupsDeprecated(
 	new SimpleGroup(
 		[new SimpleObject(oBush, 1, 3, 0, 3)],
 		true,
 		clForest
 	),
 	0,
 	[
 		stayClasses(clGrass, 3),
 		avoidClasses(
 			clWater, 1,
 			clForest, 1,
 			clPlayer, 0,
 			clMetal, 1,
 			clRock, 1)
 	],
 	numStragglers);
 RMS.SetProgress(95);
 
 log("Creating rain drops...");
 createObjectGroupsDeprecated(
 	new SimpleGroup(
 		[new SimpleObject(aRain, 2, 2, 1, 4)],
 		true,
 		clRain),
 	0,
 	avoidClasses(clRain, 5),
 	scaleByMapSize(80, 250));
 RMS.SetProgress(95);
 
 setSkySet("rain");
 setWaterType("lake");
 setWaterWaviness(2);
 setWaterColor(0.1, 0.13, 0.15);
 setWaterTint(0.058, 0.05, 0.035);
 setWaterMurkiness(0.9);
 
 setPPEffect("hdr");
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/flood.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/flood.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/flood.js	(revision 20149)
@@ -1,413 +1,400 @@
 RMS.LoadLibrary("rmgen");
 RMS.LoadLibrary("rmbiome");
 
 setSelectedBiome();
 
 const tMainTerrain = g_Terrains.mainTerrain;
 const tForestFloor1 = g_Terrains.forestFloor1;
 const tForestFloor2 = g_Terrains.forestFloor2;
 const tCliff = g_Terrains.cliff;
 const tTier1Terrain = g_Terrains.tier1Terrain;
 const tTier2Terrain = g_Terrains.tier2Terrain;
 const tTier3Terrain = g_Terrains.tier3Terrain;
 const tRoad = g_Terrains.road;
 const tRoadWild = g_Terrains.roadWild;
 const tTier4Terrain = g_Terrains.tier4Terrain;
 const tShore = g_Terrains.shore;
 const tWater = g_Terrains.water;
 let tHill = g_Terrains.hill;
 let tDirt = g_Terrains.dirt;
 
 if (currentBiome() == "temperate")
 {
 	tDirt = ["medit_shrubs_a", "grass_field"];
 	tHill = ["grass_field", "peat_temp"];
 }
 
 // Gaia entities
 const oTree1 = g_Gaia.tree1;
 const oTree2 = g_Gaia.tree2;
 const oTree3 = g_Gaia.tree3;
 const oTree4 = g_Gaia.tree4;
 const oTree5 = g_Gaia.tree5;
 const oFruitBush = g_Gaia.fruitBush;
 const oMainHuntableAnimal = g_Gaia.mainHuntableAnimal;
 const oFish = g_Gaia.fish;
 const oSecondaryHuntableAnimal = g_Gaia.secondaryHuntableAnimal;
 const oStoneLarge = g_Gaia.stoneLarge;
 const oMetalLarge = g_Gaia.metalLarge;
 
 // Decorative props
 const aGrass = g_Decoratives.grass;
 const aGrassShort = g_Decoratives.grassShort;
 const aRockLarge = g_Decoratives.rockLarge;
 const aRockMedium = g_Decoratives.rockMedium;
 const aBushMedium = g_Decoratives.bushMedium;
 const aBushSmall = g_Decoratives.bushSmall;
 
 const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
 const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
 
 InitMap();
 
 const radius = scaleByMapSize(15, 25);
 const elevation = 2;
 const shoreRadius = 6;
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 const mapArea = mapSize * mapSize;
 const centerOfMap = mapSize / 2;
 
 let clPlayer = createTileClass();
 let clHill = createTileClass();
 let clMountain = createTileClass();
 let clForest = createTileClass();
 let clWater = createTileClass();
 let clDirt = createTileClass();
 let clRock = createTileClass();
 let clMetal = createTileClass();
 let clFood = createTileClass();
 let clBaseResource = createTileClass();
 
 initTerrain(tWater);
 
-let playerIDs = sortAllPlayers();
-
-// 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]);
-}
+var [playerIDs, playerX, playerZ] = radialPlayerPlacement(0.38);
 
 let fx = fractionToTiles(0.5);
 let fz = fractionToTiles(0.5);
 let ix = round(fx);
 let iz = round(fz);
 
 // Create the water
 let placer = new ClumpPlacer(mapArea * 1, 1, 1, 1, ix, iz);
 let terrainPainter = new LayeredPainter(
     [tWater, tWater, tShore], // terrains
     [1, 4] // widths
 );
 let elevationPainter = new SmoothElevationPainter(
    ELEVATION_SET,      // type
    getMapBaseHeight(), // elevation
    2                   // blend radius
 );
 createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 5));
 
 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));
 
 for (let m = 0; m < randIntInclusive(20, 34); ++m)
 {
 	let placer = new ChainPlacer(
 		Math.floor(scaleByMapSize(7, 7)),
 		Math.floor(scaleByMapSize(15, 15)),
 		Math.floor(scaleByMapSize(15, 20)),
 		1,
 		randIntExclusive(0, mapSize),
 		randIntExclusive(0, mapSize),
 		0,
 		[Math.floor(mapSize * 0.01)]);
 
 	let elevRand = randIntInclusive(6, 20);
 	let terrainPainter = new LayeredPainter(
 		[tDirt, tHill],        // terrains
 		[floor(elevRand / 3), 40]       // widths
 	);
 	let elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,      // type
 		elevRand,           // elevation
 		floor(elevRand / 3)	// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clHill)], [avoidClasses(clBaseResource, 2, clPlayer, 40), stayClasses(clHill, 6)]);
 }
 
 for (let m = 0; m < randIntInclusive(8, 17); ++m)
 {
 	let placer = new ChainPlacer(
 		Math.floor(scaleByMapSize(5, 5)),
 		Math.floor(scaleByMapSize(8, 8)),
 		Math.floor(scaleByMapSize(15, 20)),
 		1,
 		randIntExclusive(0, mapSize),
 		randIntExclusive(0, mapSize),
 		0,
 		[Math.floor(mapSize * 0.01)]);
 
 	let elevRand = randIntInclusive(15, 29);
 	let terrainPainter = new LayeredPainter(
 		[tCliff, tForestFloor2],        // terrains
 		[floor(elevRand / 3), 40]       // widths
 	);
 	let elevationPainter = new SmoothElevationPainter(
 		ELEVATION_MODIFY,   // type
 		elevRand,           // elevation
 		floor(elevRand / 3) // blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clMountain)], [avoidClasses(clBaseResource, 2, clPlayer, 40), stayClasses(clHill, 6)]);
 }
 
 // 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
 );
 createObjectGroupsDeprecated(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,
 	...rBiomeTreeCount(0.7));
 
 log("Creating straggeler trees...");
 let types = [oTree1, oTree2, oTree4, oTree3];
 createStragglerTrees(types, [avoidClasses(clBaseResource, 2, clMetal, 6, clRock, 3, clMountain, 2, clPlayer, 25), stayClasses(clHill, 6)]);
 
 RMS.SetProgress(65);
 
 log("Creating dirt patches...");
 let sizes = [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)];
 let numb = currentBiome() == "savanna" ? 3 : 1;
 
 for (let i = 0; i < sizes.length; ++i)
 {
 	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
 	let painter = new LayeredPainter(
 		[[tMainTerrain, tTier1Terrain], [tTier1Terrain, tTier2Terrain], [tTier2Terrain, tTier3Terrain]], // terrains
 		[1, 1] // widths
 	);
 	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 = currentBiome() == "tropic" ? 8 : 1;
 createDecoration
 (
 	[
 		[new SimpleObject(aRockMedium, 1, 3, 0, 1)],
 		[new SimpleObject(aRockLarge, 1, 2, 0, 1), new SimpleObject(aRockMedium, 1, 3, 0, 2)],
 		[new SimpleObject(aGrassShort, 2, 15, 0, 1, -PI/8, PI/8)],
 		[new SimpleObject(aGrass, 2, 10, 0, 1.8, -PI/8, PI/8), new SimpleObject(aGrassShort, 3, 10, 1.2, 2.5, -PI/8, PI/8)],
 		[new SimpleObject(aBushMedium, 1, 5, 0, 2), new SimpleObject(aBushSmall, 2, 4, 0, 2)]
 	],
 	[
 		scaleByMapSize(16, 262),
 		scaleByMapSize(8, 131),
 		planetm * scaleByMapSize(13, 200),
 		planetm * scaleByMapSize(13, 200),
 		planetm * scaleByMapSize(13, 200)
 	],
 	avoidClasses(clForest, 2, clPlayer, 20, clMountain, 5, clFood, 1, clBaseResource, 2)
 );
 
 log("Creating water forests...");
 createForests(
 	[tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
 	avoidClasses(clPlayer, 30, clHill, 10, clFood, 5),
 	clForest,
 	0.1,
 	...rBiomeTreeCount(0.1));
 
 log("Creating small grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aGrassShort, 1, 2, 0, 1, -PI / 8, PI / 8)]
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clMountain, 2, clPlayer, 2, clDirt, 0), stayClasses(clHill, 8)],
 	planetm * scaleByMapSize(13, 200)
 );
 
 setSkySet(pickRandom(["cloudless", "cumulus", "overcast"]));
 setWaterMurkiness(0.4);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/fortress.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/fortress.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/fortress.js	(revision 20149)
@@ -1,360 +1,349 @@
 RMS.LoadLibrary("rmgen");
 
 const tGrass = ["temp_grass_aut", "temp_grass_aut", "temp_grass_d_aut"];
 const tForestFloor = "temp_grass_aut";
 const tGrassA = "temp_grass_plants_aut";
 const tGrassB = "temp_grass_b_aut";
 const tGrassC = "temp_grass_c_aut";
 const tDirt = ["temp_plants_bog_aut", "temp_mud_a"];
 const tHill = ["temp_highlands_aut", "temp_grass_long_b_aut"];
 const tCliff = ["temp_cliff_a", "temp_cliff_b"];
 const tRoad = "temp_road_aut";
 const tRoadWild = "temp_road_overgrown_aut";
 const tGrassPatch = "temp_grass_plants_aut";
 const tShoreBlend = "temp_grass_plants_aut";
 const tShore = "temp_plants_bog_aut";
 const tWater = "temp_mud_a";
 
 const oBeech = "gaia/flora_tree_euro_beech_aut";
 const oOak = "gaia/flora_tree_oak_aut";
 const oPine = "gaia/flora_tree_pine";
 const oDeer = "gaia/fauna_deer";
 const oFish = "gaia/fauna_fish";
 const oSheep = "gaia/fauna_rabbit";
 const oBerryBush = "gaia/flora_bush_berry";
 const oStoneLarge = "gaia/geology_stonemine_temperate_quarry";
 const oStoneSmall = "gaia/geology_stone_temperate";
 const oMetalLarge = "gaia/geology_metal_temperate_slabs";
 const oWood = "gaia/special_treasure_wood";
 const oFood = "gaia/special_treasure_food_bin";
 const oMetal = "gaia/special_treasure_metal";
 const oStone = "gaia/special_treasure_stone";
 
 const aGrass = "actor|props/flora/grass_soft_dry_small_tall.xml";
 const aGrassShort = "actor|props/flora/grass_soft_dry_large.xml";
 const aRockLarge = "actor|geology/stone_granite_med.xml";
 const aRockMedium = "actor|geology/stone_granite_med.xml";
 const aReeds = "actor|props/flora/reeds_pond_dry.xml";
 const aLillies = "actor|props/flora/water_lillies.xml";
 const aBushMedium = "actor|props/flora/bush_medit_me_dry.xml";
 const aBushSmall = "actor|props/flora/bush_medit_sm_dry.xml";
 
 const pForestD = [tForestFloor + TERRAIN_SEPARATOR + oBeech, tForestFloor];
 const pForestO = [tForestFloor + TERRAIN_SEPARATOR + oOak, tForestFloor];
 const pForestP = [tForestFloor + TERRAIN_SEPARATOR + oPine, tForestFloor];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 const mapArea = mapSize*mapSize;
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clSettlement = createTileClass();
 
-var playerIDs = sortAllPlayers();
-
-// place players
-var playerX = new Array(numPlayers);
-var playerZ = new Array(numPlayers);
-var playerAngle = new Array(numPlayers);
-var baseRadius = 30;
-
-var startAngle = randFloat(0, TWO_PI);
-for (var i = 0; i < numPlayers; i++)
-{
-	playerAngle[i] = startAngle + i*TWO_PI/numPlayers;
-	playerX[i] = mapSize*(0.5 + 0.35*cos(playerAngle[i]));
-	playerZ[i] = mapSize*(0.5 + 0.35*sin(playerAngle[i]));
-}
+var [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 for (var i=0; i < numPlayers; i++)
 {
+	playerX[i] *= mapSize;
+	playerZ[i] *= mapSize;
+
 	var startEntities = getStartingEntities(i);
 	// Place starting entities
 	createStartingPlayerEntities(playerX[i], playerZ[i], i+1, startEntities);
 	var uDist = 8;
 	var uSpace = 2;
 	for (var j = 1; j < startEntities.length - 1; ++j)
 	{
 		var uAngle = BUILDING_ORIENTATION - PI * (2-j) / 2;
 		var count = (startEntities[j].Count !== undefined ? startEntities[j].Count : 1);
 		for (var numberofentities = 0; numberofentities < count; numberofentities++)
 		{
 			var ux = playerX[i] + uDist * cos(uAngle) + numberofentities * uSpace * cos(uAngle + PI/2) - (0.75 * uSpace * floor(count / 2) * cos(uAngle + PI/2));
 			var uz = playerZ[i] + uDist * sin(uAngle) + numberofentities * uSpace * sin(uAngle + PI/2) - (0.75 * uSpace * floor(count / 2) * sin(uAngle + PI/2));
 			placeObject(ux, uz, startEntities[j].Template, i+1, uAngle);
 		}
 	}
 
 	// Create treasure
 	var bbAngle = BUILDING_ORIENTATION;
 	var bbDist = 10;
 	var bbX = round(playerX[i] + bbDist * cos(bbAngle));
 	var bbZ = round(playerZ[i] + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oFood, 5,5, 0,2)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	bbAngle += PI/2;
 	var bbX = round(playerX[i] + bbDist * cos(bbAngle));
 	var bbZ = round(playerZ[i] + bbDist * sin(bbAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oWood, 5,5, 0,2)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	bbAngle += PI/2;
 	var bbX = round(playerX[i] + bbDist * cos(bbAngle));
 	var bbZ = round(playerZ[i] + bbDist * sin(bbAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetal, 3,3, 0,2)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	bbAngle += PI/2;
 	var bbX = round(playerX[i] + bbDist * cos(bbAngle));
 	var bbZ = round(playerZ[i] + bbDist * sin(bbAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStone, 2,2, 0,2)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// Base texture
 	var civ = getCivCode(i);
 	var tilesSize = civ == "cart" ? 27 : 22;
 
 	const minBoundX = (playerX[i] > tilesSize ? playerX[i] - tilesSize : 0);
 	const minBoundY = (playerZ[i] > tilesSize ? playerZ[i] - tilesSize : 0);
 	const maxBoundX = (playerX[i] < mapSize - tilesSize ? playerX[i] + tilesSize : mapSize);
 	const maxBoundY = (playerZ[i] < mapSize - tilesSize ? playerZ[i] + tilesSize : mapSize);
 
 	for (var tx = minBoundX; tx < maxBoundX; ++tx)
 		for (var ty = minBoundY; ty < maxBoundY; ++ty)
 		{
 			var unboundSumOfXY = tx + ty - minBoundX - minBoundY;
 			if ((unboundSumOfXY > tilesSize) && (unboundSumOfXY < 3 * tilesSize) && (tx - ty + minBoundY - minBoundX < tilesSize) && (ty - tx - minBoundY + minBoundX < tilesSize))
 			{
 				placeTerrain(floor(tx), floor(ty), tRoad);
 				addToClass(floor(tx), floor(ty), clPlayer);
 			}
 		}
 
 	// Place custom fortress
 	if (civ == "brit" || civ == "gaul" || civ == "iber")
 	{
 		var wall = ["gate", "tower", "wallLong",
 			"cornerIn", "wallLong", "barracks", "tower", "wallLong", "tower", "house", "wallLong",
 			"cornerIn", "wallLong", "house", "tower", "gate", "tower", "house", "wallLong",
 			"cornerIn", "wallLong", "house", "tower", "wallLong", "tower", "house", "wallLong",
 			"cornerIn", "wallLong", "house", "tower"];
 	}
 	else
 	{
 		var wall = ["gate", "tower", "wallLong",
 			"cornerIn", "wallLong", "barracks", "tower", "wallLong", "tower", "wallLong",
 			"cornerIn", "wallLong", "house", "tower", "gate", "tower", "wallLong",
 			"cornerIn", "wallLong", "house", "tower", "wallLong", "tower", "wallLong",
 			"cornerIn", "wallLong", "house", "tower"];
 	}
 	placeCustomFortress(playerX[i], playerZ[i], new Fortress("Spahbod", wall), civ, i+1);
 }
 
 log("Creating lakes...");
 var numLakes = round(scaleByMapSize(1,4) * numPlayers);
 var placer = new ClumpPlacer(scaleByMapSize(100,250), 0.8, 0.1, 10);
 var terrainPainter = new LayeredPainter(
 	[tShore, tWater, tWater],		// terrains
 	[1,1]							// widths
 );
 var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -4, 3);
 var waterAreas = createAreas(
 	placer,
 	[terrainPainter, elevationPainter, paintClass(clWater)],
 	avoidClasses(clPlayer, 7, clWater, 20),
 	numLakes
 );
 RMS.SetProgress(15);
 
 log("Creating reeds...");
 group = new SimpleGroup(
 	[new SimpleObject(aReeds, 5,10, 0,4), new SimpleObject(aLillies, 0,1, 0,4)], true
 );
 createObjectGroupsByAreasDeprecated(group, 0,
 	[borderClasses(clWater, 3, 0), stayClasses(clWater, 1)],
 	numLakes, 100,
 	waterAreas
 );
 RMS.SetProgress(25);
 
 log("Creating fish...");
 createObjectGroupsByAreasDeprecated(
 	new SimpleGroup(
 		[new SimpleObject(oFish, 1,1, 0,1)],
 		true, clFood
 	),
 	0,
 	[stayClasses(clWater, 4),  avoidClasses(clFood, 8)],
 	numLakes / 4,
 	50,
 	waterAreas
 );
 RMS.SetProgress(30);
 
 createBumps(avoidClasses(clWater, 2, clPlayer, 5));
 RMS.SetProgress(35);
 
 log("Creating hills...");
 createHills([tCliff, tCliff, tHill], avoidClasses(clPlayer, 5, clWater, 5, clHill, 15), clHill, scaleByMapSize(1, 4) * numPlayers);
 RMS.SetProgress(40);
 
 // calculate desired number of trees for map (based on size)
 const MIN_TREES = 500;
 const MAX_TREES = 2500;
 const P_FOREST = 0.7;
 
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 var numForest = totalTrees * P_FOREST;
 g_numStragglerTrees = totalTrees * (1.0 - P_FOREST);
 
 log("Creating forests...");
 var types = [
 	[[tForestFloor, tGrass, pForestD], [tForestFloor, pForestD]],
 	[[tForestFloor, tGrass, pForestO], [tForestFloor, pForestO]],
 	[[tForestFloor, tGrass, pForestP], [tForestFloor, pForestP]]
 ];	// some variation
 var size = numForest / (scaleByMapSize(3,6) * numPlayers);
 var num = floor(size / types.length);
 for (var i = 0; i < types.length; ++i)
 {
 	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), numForest / num, 0.5);
 	var painter = new LayeredPainter(
 		types[i],		// terrains
 		[2]											// widths
 		);
 	createAreas(
 		placer,
 		[painter, paintClass(clForest)],
 		avoidClasses(clPlayer, 5, clWater, 3, clForest, 15, clHill, 1),
 		num
 	);
 }
 RMS.SetProgress(50);
 
 log("Creating dirt patches...");
 createLayeredPatches(
  [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
  [[tGrass,tGrassA],[tGrassA,tGrassB], [tGrassB,tGrassC]],
  [1,1],
  avoidClasses(clWater, 1, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 1)
 );
 RMS.SetProgress(55);
 
 log("Creating grass patches...");
 createPatches(
  [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
  tGrassPatch,
  avoidClasses(clWater, 1, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 1)
 );
 RMS.SetProgress(60);
 
 log("Creating stone mines...");
 createMines(
  [
   [new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)],
   [new SimpleObject(oStoneSmall, 2,5, 1,3)]
  ],
  avoidClasses(clWater, 0, clForest, 1, clPlayer, 5, clRock, 10, clHill, 1)
 );
 RMS.SetProgress(65);
 
 log("Creating metal mines...");
 createMines(
  [
   [new SimpleObject(oMetalLarge, 1,1, 0,4)]
  ],
  avoidClasses(clWater, 0, clForest, 1, clPlayer, 5, clMetal, 10, clRock, 5, clHill, 1),
  clMetal
 );
 RMS.SetProgress(70);
 
 createDecoration
 (
  [[new SimpleObject(aRockMedium, 1,3, 0,1)],
   [new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
   [new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)],
   [new SimpleObject(aGrass, 2,4, 0,1.8, -PI/8,PI/8), new SimpleObject(aGrassShort, 3,6, 1.2,2.5, -PI/8,PI/8)],
   [new SimpleObject(aBushMedium, 1,2, 0,2), new SimpleObject(aBushSmall, 2,4, 0,2)]
  ],
  [
   scaleByMapSize(16, 262),
   scaleByMapSize(8, 131),
   scaleByMapSize(13, 200),
   scaleByMapSize(13, 200),
   scaleByMapSize(13, 200)
  ],
  avoidClasses(clWater, 0, clForest, 0, clPlayer, 1, clHill, 0)
 );
 RMS.SetProgress(80);
 
 createFood
 (
  [
   [new SimpleObject(oSheep, 2,3, 0,2)],
   [new SimpleObject(oDeer, 5,7, 0,4)]
  ],
  [
   3 * numPlayers,
   3 * numPlayers
  ],
  avoidClasses(clWater, 0, clForest, 0, clPlayer, 6, clHill, 1, clFood, 20)
 );
 RMS.SetProgress(85);
 
 createFood
 (
  [
   [new SimpleObject(oBerryBush, 5,7, 0,4)]
  ],
  [
   randIntInclusive(1, 4) * numPlayers + 2
  ],
  avoidClasses(clWater, 2, clForest, 0, clPlayer, 6, clHill, 1, clFood, 10)
 );
 
 RMS.SetProgress(90);
 
 log("Creating straggler trees...");
 var types = [oOak, oBeech, oPine];	// some variation
 createStragglerTrees(types, avoidClasses(clWater, 1, clForest, 1, clHill, 1, clPlayer, 1, clMetal, 6, clRock, 6));
 RMS.SetProgress(95);
 
 setSkySet("sunny");
 setWaterColor(0.157, 0.149, 0.443);
 setWaterTint(0.443,0.42,0.824);
 setWaterWaviness(2.0);
 setWaterType("lake");
 setWaterMurkiness(0.83);
 
 setFogFactor(0.35);
 setFogThickness(0.22);
 setFogColor(0.82,0.82, 0.73);
 setPPSaturation(0.56);
 setPPContrast(0.56);
 setPPBloom(0.38);
 setPPEffect("hdr");
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/gear.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/gear.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/gear.js	(revision 20149)
@@ -1,453 +1,440 @@
 RMS.LoadLibrary("rmgen");
 RMS.LoadLibrary("rmbiome");
 
 TILE_CENTERED_HEIGHT_MAP = true;
 
 setSelectedBiome();
 
 const tMainTerrain = g_Terrains.mainTerrain;
 const tForestFloor1 = g_Terrains.forestFloor1;
 const tForestFloor2 = g_Terrains.forestFloor2;
 const tCliff = g_Terrains.cliff;
 const tTier1Terrain = g_Terrains.tier1Terrain;
 const tTier2Terrain = g_Terrains.tier2Terrain;
 const tTier3Terrain = g_Terrains.tier3Terrain;
 const tHill = g_Terrains.mainTerrain;
 const tDirt = g_Terrains.dirt;
 const tRoad = g_Terrains.road;
 const tRoadWild = g_Terrains.roadWild;
 const tTier4Terrain = g_Terrains.tier4Terrain;
 const tShoreBlend = g_Terrains.shoreBlend;
 const tShore = g_Terrains.shore;
 const tWater = g_Terrains.water;
 
 const oTree1 = g_Gaia.tree1;
 const oTree2 = g_Gaia.tree2;
 const oTree3 = g_Gaia.tree3;
 const oTree4 = g_Gaia.tree4;
 const oTree5 = g_Gaia.tree5;
 const oFruitBush = g_Gaia.fruitBush;
 const oMainHuntableAnimal = g_Gaia.mainHuntableAnimal;
 const oFish = g_Gaia.fish;
 const oSecondaryHuntableAnimal = g_Gaia.secondaryHuntableAnimal;
 const oStoneLarge = g_Gaia.stoneLarge;
 const oStoneSmall = g_Gaia.stoneSmall;
 const oMetalLarge = g_Gaia.metalLarge;
 
 const aGrass = g_Decoratives.grass;
 const aGrassShort = g_Decoratives.grassShort;
 const aReeds = g_Decoratives.reeds;
 const aLillies = g_Decoratives.lillies;
 const aRockLarge = g_Decoratives.rockLarge;
 const aRockMedium = g_Decoratives.rockMedium;
 const aBushMedium = g_Decoratives.bushMedium;
 const aBushSmall = g_Decoratives.bushSmall;
 
 const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
 const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 const mapArea = mapSize*mapSize;
 
 log(mapSize);
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clSettlement = createTileClass();
 var clLand = createTileClass();
 
 initTerrain(tMainTerrain);
 
 var fx = fractionToTiles(0.5);
 var fz = fractionToTiles(0.5);
 var ix = round(fx);
 var iz = round(fz);
 
 var lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 8))));
 
 var placer = new ClumpPlacer(mapArea * 0.23, 1, 1, 10, ix, iz);
 var terrainPainter = new LayeredPainter(
 	[tShore, tWater, tWater, tWater],		// terrains
 	[1, 4, 2]		// widths
 );
 var elevationPainter = new SmoothElevationPainter(
 	ELEVATION_SET,			// type
 	-3,				// elevation
 	4				// blend radius
 );
 createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], null);
 
-var playerIDs = sortAllPlayers();
-
-// 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 [playerIDs, playerX, playerZ, playerAngle, startAngle] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	fx = fractionToTiles(playerX[i]);
 	fz = fractionToTiles(playerZ[i]);
 	ix = round(fx);
 	iz = round(fz);
 	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, { 'iberWall': 'towers' });
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oFruitBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 		mAngle = randFloat(0, TWO_PI);
 
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var num = 2;
 	var tAngle = randFloat(0, TWO_PI);
 	var tDist = randFloat(12, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oTree1, num, num, 0,3)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 
 RMS.SetProgress(20);
 
 var split = 1;
 if (mapSize == 128 && numPlayers <= 2)
 	split = 2;
 else if (mapSize == 192 && numPlayers <= 3)
 	split = 2;
 else if (mapSize == 256)
 {
 	if (numPlayers <= 3)
 		split = 3;
 	else if (numPlayers == 4)
 		split = 2;
 }
 else if (mapSize == 320)
 {
 	if (numPlayers <= 3)
 		split = 3;
 	else if (numPlayers == 4)
 		split = 2;
 }
 else if (mapSize == 384)
 {
 	if (numPlayers <= 3)
 		split = 4;
 	else if (numPlayers == 4)
 		split = 3;
 	else if (numPlayers == 5)
 		split = 2;
 }
 else if (mapSize == 448)
 {
 	if (numPlayers <= 2)
 		split = 5;
 	else if (numPlayers <= 4)
 		split = 4;
 	else if (numPlayers == 5)
 		split = 3;
 	else if (numPlayers == 6)
 		split = 2;
 }
 
 log ("Creating rivers...");
 for (var m = 0; m < numPlayers*split; m++)
 {
 	var tang = startAngle + (m+0.5)*TWO_PI/(numPlayers*split);
 	var placer = new PathPlacer(fractionToTiles(0.5 + 0.15*cos(tang)), fractionToTiles(0.5 + 0.15*sin(tang)), fractionToTiles(0.5 + 0.49*cos(tang)), fractionToTiles(0.5 + 0.49*sin(tang)), scaleByMapSize(14,40), 0.0, 3*(scaleByMapSize(1,3)), 0.2, 0.05);
 	var terrainPainter = new LayeredPainter(
 		[tShore, tWater, tWater],		// terrains
 		[1, 3]								// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		-4,				// elevation
 		4				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 5));
 	placer = new ClumpPlacer(floor(PI*scaleByMapSize(14,40)*scaleByMapSize(14,40)/4), 1, 0, 10, fractionToTiles(0.5 + 0.49*cos(tang)), fractionToTiles(0.5 + 0.49*sin(tang)));
 	var painter = new LayeredPainter([tWater, tWater], [1]);
 	var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -4, 4);
 	createArea(placer, [painter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 5));
 
 	var tang = startAngle + (m)*TWO_PI/(numPlayers*split);
 	var placer = new PathPlacer(fractionToTiles(0.5 + 0.05*cos(tang)), fractionToTiles(0.5 + 0.05*sin(tang)), fractionToTiles(0.5 + 0.49*cos(tang)), fractionToTiles(0.5 + 0.49*sin(tang)), scaleByMapSize(10,40), 0.0, 3*(scaleByMapSize(1,3)), 0.2, 0.05);
 	var terrainPainter = new LayeredPainter(
 		[tWater, tShore, tMainTerrain],		// terrains
 		[1, 3]								// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		3,				// elevation
 		4				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter], null);
 }
 
 var fx = fractionToTiles(0.5);
 var fz = fractionToTiles(0.5);
 ix = round(fx);
 iz = round(fz);
 
 var placer = new ClumpPlacer(mapArea * 0.15, 1, 1, 10, ix, iz);
 var terrainPainter = new LayeredPainter(
 	[tShore, tWater, tWater, tWater],		// terrains
 	[1, 4, 2]		// widths
 );
 var elevationPainter = new SmoothElevationPainter(
 	ELEVATION_SET,			// type
 	4,				// elevation
 	4				// blend radius
 );
 createArea(placer, [terrainPainter, elevationPainter, unPaintClass(clWater)], null);
 
 var fx = fractionToTiles(0.5);
 var fz = fractionToTiles(0.5);
 ix = round(fx);
 iz = round(fz);
 
 var lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 8))));
 
 var placer = new ClumpPlacer(mapArea * 0.09, 1, 1, 10, ix, iz);
 var terrainPainter = new LayeredPainter(
 	[tShore, tWater, tWater],		// terrains
 	[1, 3]								// widths
 );
 var elevationPainter = new SmoothElevationPainter(
 	ELEVATION_SET,			// type
 	-2,				// elevation
 	3				// blend radius
 );
 createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], null);
 
 var placer = new ClumpPlacer((mapSize - 50) * (mapSize - 50) * 0.09, 1, 1, 10, ix, iz);
 var terrainPainter = new LayeredPainter(
 	[tShore, tWater, tWater, tWater],		// terrains
 	[1, 4, 2]		// widths
 );
 var elevationPainter = new SmoothElevationPainter(
 	ELEVATION_SET,			// type
 	4,				// elevation
 	3				// blend radius
 );
 createArea(placer, [terrainPainter, elevationPainter, unPaintClass(clWater)], null);
 
 var placer = new ClumpPlacer(scaleByMapSize(6, 18)*scaleByMapSize(6, 18)*22, 1, 1, 10, ix, iz);
 var terrainPainter = new LayeredPainter(
 	[tMainTerrain, tMainTerrain],		// terrains
 	[1]		// widths
 );
 var elevationPainter = new SmoothElevationPainter(
 	ELEVATION_SET,			// type
 	20,				// elevation
 	8				// blend radius
 );
 createArea(placer, [terrainPainter, elevationPainter], null);
 
 paintTerrainBasedOnHeight(-6, 1, 1, tWater);
 paintTerrainBasedOnHeight(1, 2, 1, tShore);
 paintTerrainBasedOnHeight(2, 5, 1, tMainTerrain);
 
 paintTileClassBasedOnHeight(-6, 0.5, 1, clWater);
 unPaintTileClassBasedOnHeight(0.5, 10, 1, clWater);
 
 for (var i = 0; i < numPlayers; i++)
 {
 	fx = fractionToTiles(playerX[i]);
 	fz = fractionToTiles(playerZ[i]);
 	ix = round(fx);
 	iz = round(fz);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	var placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tRoadWild, tRoad], [1]);
 	createArea(placer, painter, null);
 }
 
 if (randBool())
 	createHills([tMainTerrain, tCliff, tHill], avoidClasses(clPlayer, 20, clHill, 15, clWater, 2), clHill, scaleByMapSize(1, 4) * numPlayers);
 else
 	createMountains(tCliff, avoidClasses(clPlayer, 20, clHill, 15, clWater, 2), clHill, scaleByMapSize(1, 4) * numPlayers);
 
 createForests(
  [tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
  avoidClasses(clPlayer, 20, clForest, 17, clHill, 0, clWater, 2),
  clForest,
  1,
  ...rBiomeTreeCount(1));
 
 RMS.SetProgress(50);
 
 log("Creating dirt patches...");
 createLayeredPatches(
  [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
  [[tMainTerrain,tTier1Terrain],[tTier1Terrain,tTier2Terrain], [tTier2Terrain,tTier3Terrain]],
  [1,1],
  avoidClasses(clWater, 3, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12)
 );
 
 log("Creating grass patches...");
 createPatches(
  [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
  tTier4Terrain,
  avoidClasses(clWater, 3, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12)
 );
 
 RMS.SetProgress(55);
 
 log("Creating stone mines...");
 createMines(
  [
   [new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)],
   [new SimpleObject(oStoneSmall, 2,5, 1,3)]
  ],
  avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clRock, 10, clHill, 1)
 );
 
 log("Creating metal mines...");
 createMines(
  [
   [new SimpleObject(oMetalLarge, 1,1, 0,4)]
  ],
  avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 1),
  clMetal
 );
 
 log("Creating fish...");
 createObjectGroupsDeprecated(
 	new SimpleGroup([new SimpleObject(oFish, 1,1, 0,3)], true, clFood),
 	0,
 	[stayClasses(clWater, 8), avoidClasses(clFood, 14)],
 	scaleByMapSize(400, 2000),
 	100);
 
 RMS.SetProgress(65);
 
 var planetm = 1;
 
 if (currentBiome() == "tropic")
 	planetm = 8;
 
 createDecoration
 (
  [[new SimpleObject(aRockMedium, 1,3, 0,1)],
   [new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
   [new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)],
   [new SimpleObject(aGrass, 2,4, 0,1.8, -PI/8,PI/8), new SimpleObject(aGrassShort, 3,6, 1.2,2.5, -PI/8,PI/8)],
   [new SimpleObject(aBushMedium, 1,2, 0,2), new SimpleObject(aBushSmall, 2,4, 0,2)]
  ],
  [
   scaleByMapSize(16, 262),
   scaleByMapSize(8, 131),
   planetm * scaleByMapSize(13, 200),
   planetm * scaleByMapSize(13, 200),
   planetm * scaleByMapSize(13, 200)
  ],
  avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0)
 );
 
 RMS.SetProgress(70);
 
 createFood
 (
  [
   [new SimpleObject(oMainHuntableAnimal, 5,7, 0,4)],
   [new SimpleObject(oSecondaryHuntableAnimal, 2,3, 0,2)]
  ],
  [
   3 * numPlayers,
   3 * numPlayers
  ],
  avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 20)
 );
 
 createFood
 (
  [
   [new SimpleObject(oFruitBush, 5,7, 0,4)]
  ],
  [
   3 * numPlayers
  ],
  avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 10)
 );
 
 var types = [oTree1, oTree2, oTree4, oTree3];	// some variation
 createStragglerTrees(types, avoidClasses(clWater, 5, clForest, 7, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6));
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/india.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/india.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/india.js	(revision 20149)
@@ -1,324 +1,313 @@
 RMS.LoadLibrary("rmgen");
 
 const tGrass1 = "savanna_grass_a";
 const tDirt1 = "savanna_dirt_a";
 const tDirt4 = "savanna_dirt_b";
 const tCityTiles = "savanna_tile_a_dirt_red";
 const tShore = "savanna_riparian_bank";
 const tWater = "savanna_riparian_wet";
 
 const oTree = "gaia/flora_tree_palm_tropic";
 const oBerryBush = "gaia/flora_bush_berry";
 const oRabbit = "gaia/fauna_rabbit";
 const oTiger = "gaia/fauna_tiger";
 const oCrocodile = "gaia/fauna_crocodile";
 const oFish = "gaia/fauna_fish";
 const oElephant = "gaia/fauna_elephant_asian";
 const oElephantInfant = "gaia/fauna_elephant_asian_infant";
 const oBoar = "gaia/fauna_boar";
 const oStoneSmall = "gaia/geology_stone_savanna_small";
 const oMetalLarge = "gaia/geology_metal_savanna_slabs";
 
 const aBush = "actor|props/flora/bush_medit_sm_dry.xml";
 const aRock = "actor|geology/stone_savanna_med.xml";
 
 InitMap();
 
 var numPlayers = getNumPlayers();
 var mapSize = getMapSize();
 
 var clPlayer = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 
-var playerIDs = sortAllPlayers();
-
-var playerX = [];
-var playerZ = [];
-var startAngle = randFloat(0, 2 * PI);
-
-for (let i = 0; i < numPlayers; ++i)
-{
-	let playerAngle = startAngle + i * 2 * PI / numPlayers;
-	playerX[i] = 0.5 + 0.35 * Math.cos(playerAngle);
-	playerZ[i] = 0.5 + 0.35 * Math.sin(playerAngle);
-}
+var [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 for (let i = 0; i < numPlayers; ++i)
 {
 	let id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	let fx = fractionToTiles(playerX[i]);
 	let fz = fractionToTiles(playerZ[i]);
 	let ix = Math.round(fx);
 	let iz = Math.round(fz);
 
 	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
 	let radius = scaleByMapSize(15, 25);
 	let cityRadius = radius / 3;
 	createArea(
 		new ClumpPlacer(PI * cityRadius * cityRadius, 0.6, 0.3, 10, ix, iz),
 		new LayeredPainter([tDirt1, tCityTiles], [1]),
 		null);
 
 	placeCivDefaultEntities(fx, fz, id);
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// Create berry bushes
 	var bbAngle = randFloat(0, 2 * PI);
 	var bbDist = 12;
 	var bbX = Math.round(fx + bbDist * Math.cos(bbAngle));
 	var bbZ = Math.round(fz + bbDist * Math.sin(bbAngle));
 	createObjectGroup(
 		new SimpleGroup(
 			[new SimpleObject(oBerryBush, 5,5, 0,3)],
 			true, clBaseResource, bbX, bbZ
 		),
 		0);
 
 	// Create metal mine
 	var mAngle = bbAngle;
 	while (Math.abs(mAngle - bbAngle) < PI/3)
 		mAngle = randFloat(0, 2 * PI);
 	var mDist = 13;
 	var mX = Math.round(fx + mDist * Math.cos(mAngle));
 	var mZ = Math.round(fz + mDist * Math.sin(mAngle));
 	createObjectGroup(
 		new SimpleGroup(
 			[new SimpleObject(oMetalLarge, 1, 1, 0, 0)],
 			true, clBaseResource, mX, mZ
 		),
 		0);
 
 	// Create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = Math.round(fx + mDist * Math.cos(mAngle));
 	mZ = Math.round(fz + mDist * Math.sin(mAngle));
 	createStoneMineFormation(mX, mZ, tDirt4);
 	addToClass(mX, mZ, clPlayer);
 
 	// Create starting trees
 	var num = Math.floor(PI * radius * radius / 300);
 	var tAngle = randFloat(-PI/3, 4 * PI/3);
 	var tDist = randFloat(13, 15);
 	var tX = Math.round(fx + tDist * Math.cos(tAngle));
 	var tZ = Math.round(fz + tDist * Math.sin(tAngle));
 	createObjectGroup(
 		new SimpleGroup(
 			[new SimpleObject(oTree, num, num, 4, 6)],
 			false, clBaseResource, tX, tZ
 		),
 		0,
 		avoidClasses(clBaseResource,2));
 }
 RMS.SetProgress(20);
 
 log("Creating bumps...");
 createAreas(
 	new ClumpPlacer(scaleByMapSize(20, 50), 0.5, 0.08, 1),
 	new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2),
 	avoidClasses(clPlayer, 13),
 	scaleByMapSize(300, 800)
 );
 
 log("Creating the half dried-up lake...");
 createArea(
 	new ChainPlacer(
 		2,
 		Math.floor(scaleByMapSize(2, 16)),
 		Math.floor(scaleByMapSize(35, 200)),
 		1,
 		Math.round(fractionToTiles(0.5)),
 		Math.round(fractionToTiles(0.5)),
 		0,
 		[Math.floor(mapSize * 0.008 * Math.pow(scaleByMapSize(1, 66), 1/8))]),
 	[
 		new SmoothElevationPainter(ELEVATION_SET, -3, 4),
 		paintClass(clWater)
 	],
 	avoidClasses(clPlayer, 20));
 
 log("Creating more shore jaggedness...");
 createAreas(
 	new ChainPlacer(2, Math.floor(scaleByMapSize(4, 6)), 3, 1),
 	[
 		new SmoothElevationPainter(ELEVATION_SET, 3, 4),
 		unPaintClass(clWater)
 	],
 	borderClasses(clWater, 4, 7),
 	scaleByMapSize(12, 130) * 2, 150
 );
 
 paintTerrainBasedOnHeight(2.4, 3.4, 3, tGrass1);
 paintTerrainBasedOnHeight(1, 2.4, 0, tShore);
 paintTerrainBasedOnHeight(-8, 1, 2, tWater);
 paintTileClassBasedOnHeight(-6, 0, 1, clWater);
 RMS.SetProgress(55);
 
 var playerConstraint = new AvoidTileClassConstraint(clPlayer, 30);
 var minesConstraint = new AvoidTileClassConstraint(clRock, 25);
 var waterConstraint = new AvoidTileClassConstraint(clWater, 10);
 
 log("Creating stone mines...");
 for (let i = 0; i < scaleByMapSize(12, 30); ++i)
 {
 	let mX = randIntInclusive(1, mapSize - 1);
 	let mZ = randIntInclusive(1, mapSize - 1);
 	if (playerConstraint.allows(mX, mZ) && minesConstraint.allows(mX, mZ) && waterConstraint.allows(mX, mZ))
 	{
 		createStoneMineFormation(mX, mZ, tDirt4);
 		addToClass(mX, mZ, clRock);
 	}
 }
 
 log("Creating metal mines...");
 createObjectGroupsDeprecated(
 	new SimpleGroup([new SimpleObject(oMetalLarge, 1, 1, 0, 4)], true, clMetal),
 	0,
 	avoidClasses(clPlayer, 20, clMetal, 10, clRock, 8, clWater, 4),
 	scaleByMapSize(2, 12), 100
 );
 RMS.SetProgress(65);
 
 log("Creating small decorative rocks...");
 createObjectGroupsDeprecated(
 	new SimpleGroup(
 		[new SimpleObject(aRock, 1, 3, 0, 3)],
 		true
 	),
 	0,
 	avoidClasses(clPlayer, 7, clWater, 1),
 	scaleByMapSize(200, 1200), 1
 );
 RMS.SetProgress(70);
 
 log("Creating boar...");
 createObjectGroupsDeprecated(
 	new SimpleGroup(
 		[new SimpleObject(oBoar, 1, 2, 0, 4)],
 		true, clFood
 	),
 	0,
 	avoidClasses(clWater, 1, clPlayer, 20, clFood, 11),
 	scaleByMapSize(4, 12), 50
 );
 
 log("Creating tigers...");
 createObjectGroupsDeprecated(
 	new SimpleGroup(
 		[new SimpleObject(oTiger, 2, 2, 0, 4)],
 		true, clFood
 	),
 	0,
 	avoidClasses(clWater, 1, clPlayer, 20, clFood, 11),
 	scaleByMapSize(4, 12), 50
 );
 
 log("Creating crocodiles...");
 createObjectGroupsDeprecated(
 	new SimpleGroup(
 		[new SimpleObject(oCrocodile, 2, 4, 0, 4)],
 		true, clFood
 	), 0,
 	stayClasses(clWater, 1),
 	scaleByMapSize(4, 12), 50
 );
 
 log("Creating elephants...");
 createObjectGroupsDeprecated(
 	new SimpleGroup(
 		[
 			new SimpleObject(oElephant, 2, 4, 0, 4),
 			new SimpleObject(oElephantInfant, 1, 2, 0, 4)
 		],
 		true, clFood
 	),
 	0,
 	avoidClasses(clWater, 1, clPlayer, 20, clFood, 11),
 	scaleByMapSize(4, 12), 50
 );
 
 log("Creating rabbits...");
 createObjectGroupsDeprecated(
 	new SimpleGroup(
 		[new SimpleObject(oRabbit, 5, 6, 0, 4)],
 		true, clFood
 	),
 	0,
 	avoidClasses(clWater, 1, clPlayer, 20, clFood, 11),
 	scaleByMapSize(4, 12), 50
 );
 
 createFood(
 	[
 		[new SimpleObject(oFish, 2, 3, 0, 2)]
 	],
 	[
 		25 * numPlayers
 	],
 	[avoidClasses(clFood, 20), stayClasses(clWater, 2)]
 );
 
 log("Creating berry bush...");
 createObjectGroupsDeprecated(
 	new SimpleGroup(
 		[new SimpleObject(oBerryBush, 5, 7, 0, 4)],
 		true, clFood
 	),
 	0,
 	avoidClasses(clWater, 3, clPlayer, 20, clFood, 12, clRock, 7, clMetal, 2),
 	randIntInclusive(1, 4) * numPlayers + 2, 50
 );
 RMS.SetProgress(85);
 
 log("Creating trees...");
 createObjectGroupsDeprecated(
 	new SimpleGroup(
 		[new SimpleObject(oTree, 1, 7, 0, 3)],
 		true, clForest
 	),
 	0,
 	avoidClasses(clForest, 1, clPlayer, 20, clMetal, 1, clRock, 7, clWater, 1),
 	scaleByMapSize(70, 500)
 );
 
 log("Creating large grass tufts...");
 createObjectGroupsDeprecated(
 	new SimpleGroup(
 		[new SimpleObject(aBush, 2, 4, 0, 1.8, -PI/8, PI/8)]
 	),
 	0,
 	avoidClasses(clWater, 3, clPlayer, 2, clForest, 0),
 	scaleByMapSize(100, 1200)
 );
 
 setSunColor(0.87451, 0.847059, 0.647059);
 setWaterColor(0.741176, 0.592157, 0.27451);
 setWaterTint(0.741176, 0.592157, 0.27451);
 setWaterWaviness(2.0);
 setWaterType("clap");
 setWaterMurkiness(0.835938);
 
 setUnitsAmbientColor(0.57, 0.58, 0.55);
 setTerrainAmbientColor(0.447059, 0.509804, 0.54902);
 
 setFogFactor(0.25);
 setFogThickness(0.15);
 setFogColor(0.847059, 0.737255, 0.482353);
 
 setPPEffect("hdr");
 setPPContrast(0.57031);
 setPPBloom(0.34);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/islands.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/islands.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/islands.js	(revision 20149)
@@ -1,538 +1,525 @@
 RMS.LoadLibrary("rmgen");
 RMS.LoadLibrary("rmbiome");
 
 TILE_CENTERED_HEIGHT_MAP = true;
 
 setSelectedBiome();
 
 const tMainTerrain = g_Terrains.mainTerrain;
 const tForestFloor1 = g_Terrains.forestFloor1;
 const tForestFloor2 = g_Terrains.forestFloor2;
 const tCliff = g_Terrains.cliff;
 const tTier1Terrain = g_Terrains.tier1Terrain;
 const tTier2Terrain = g_Terrains.tier2Terrain;
 const tTier3Terrain = g_Terrains.tier3Terrain;
 const tHill = g_Terrains.hill;
 const tDirt = g_Terrains.dirt;
 const tRoad = g_Terrains.road;
 const tRoadWild = g_Terrains.roadWild;
 const tTier4Terrain = g_Terrains.tier4Terrain;
 const tShoreBlend = g_Terrains.shoreBlend;
 const tShore = g_Terrains.shore;
 const tWater = g_Terrains.water;
 
 const oTree1 = g_Gaia.tree1;
 const oTree2 = g_Gaia.tree2;
 const oTree3 = g_Gaia.tree3;
 const oTree4 = g_Gaia.tree4;
 const oTree5 = g_Gaia.tree5;
 const oFruitBush = g_Gaia.fruitBush;
 const oMainHuntableAnimal = g_Gaia.mainHuntableAnimal;
 const oFish = g_Gaia.fish;
 const oSecondaryHuntableAnimal = g_Gaia.secondaryHuntableAnimal;
 const oStoneLarge = g_Gaia.stoneLarge;
 const oStoneSmall = g_Gaia.stoneSmall;
 const oMetalLarge = g_Gaia.metalLarge;
 const oWood = "gaia/special_treasure_wood";
 
 const aGrass = g_Decoratives.grass;
 const aGrassShort = g_Decoratives.grassShort;
 const aReeds = g_Decoratives.reeds;
 const aLillies = g_Decoratives.lillies;
 const aRockLarge = g_Decoratives.rockLarge;
 const aRockMedium = g_Decoratives.rockMedium;
 const aBushMedium = g_Decoratives.bushMedium;
 const aBushSmall = g_Decoratives.bushSmall;
 
 const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
 const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 const mapArea = mapSize*mapSize;
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clSettlement = createTileClass();
 var clLand = createTileClass();
 
-var playerIDs = sortAllPlayers();
-
-// 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 [playerIDs, playerX, playerZ, playerAngle] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(20,29);
 	var shoreRadius = 6;
 	var elevation = 3;
 
 	var hillSize = PI * radius * radius;
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 	// create the hill
 	var placer = new ClumpPlacer(hillSize, 0.80, 0.1, 10, ix, iz);
 	var terrainPainter = new LayeredPainter(
 		[tMainTerrain , tMainTerrain, tMainTerrain],		// terrains
 		[1, shoreRadius]		// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		elevation,				// elevation
 		shoreRadius				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clPlayer)], null);
 
 	placeCivDefaultEntities(fx, fz, id, { 'iberWall': 'towers' });
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oFruitBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create woods
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 13;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oWood, 14,14, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 	var hillSize = PI * radius * radius;
 	// create starting trees
 	var num = 5;
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(12, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oTree1, num, num, 0,3)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 
 	//create docks
 	var dockLocation = getTIPIADBON([ix, iz], [mapSize / 2, mapSize / 2], [-3 , 2.6], 0.5, 3);
 	if (dockLocation !== undefined)
 		placeObject(dockLocation[0], dockLocation[1], "structures/" + getCivCode(id-1) + "_dock", id, playerAngle[i] + PI);
 }
 
 var landAreas = [];
 var playerConstraint = new AvoidTileClassConstraint(clPlayer, floor(scaleByMapSize(12,16)));
 var landConstraint = new AvoidTileClassConstraint(clLand, floor(scaleByMapSize(12,16)));
 
 for (var x = 0; x < mapSize; ++x)
 	for (var z = 0; z < mapSize; ++z)
 		if (playerConstraint.allows(x, z) && landConstraint.allows(x, z))
 			landAreas.push([x, z]);
 
 var chosenPoint;
 var landAreaLen;
 
 log("Creating big islands...");
 var numIslands = scaleByMapSize(4, 14);
 for (var i = 0; i < numIslands; ++i)
 {
 	landAreaLen = landAreas.length;
 	if (!landAreaLen)
 		break;
 
 	chosenPoint = pickRandom(landAreas);
 
 	// create big islands
 	placer = new ChainPlacer(floor(scaleByMapSize(4, 8)), floor(scaleByMapSize(8, 14)), floor(scaleByMapSize(25, 60)), 0.07, chosenPoint[0], chosenPoint[1], scaleByMapSize(30,70));
 	//placer = new ClumpPlacer(floor(hillSize*randFloat(0.9,2.1)), 0.80, 0.1, 0.07, chosenPoint[0], chosenPoint[1]);
 	terrainPainter = new LayeredPainter(
 		[tMainTerrain, tMainTerrain],		// terrains
 		[2]								// widths
 	);
 	elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 6);
 	var newIsland = createAreas(
 		placer,
 		[terrainPainter, elevationPainter, paintClass(clLand)],
 		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 = pickRandom(landAreas);
 
 	placer = new ChainPlacer(floor(scaleByMapSize(4, 7)), floor(scaleByMapSize(7, 10)), floor(scaleByMapSize(16, 40)), 0.07, chosenPoint[0], chosenPoint[1], scaleByMapSize(22,40));
 	terrainPainter = new LayeredPainter(
 		[tMainTerrain, tMainTerrain],		// terrains
 		[2]								// widths
 	);
 	elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 6);
 	createAreas(
 		placer,
 		[terrainPainter, elevationPainter, paintClass(clLand)],
 		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);
 }
 
 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)
 );
 
 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 (currentBiome() == "savanna")
 {
 	var MIN_TREES = 200;
 	var MAX_TREES = 1250;
 	var P_FOREST = 0;
 }
 else if (currentBiome() == "tropic")
 {
 	var MIN_TREES = 1000;
 	var MAX_TREES = 6000;
 	var P_FOREST = 0.52;
 }
 else
 {
 	var MIN_TREES = 500;
 	var MAX_TREES = 3000;
 	var P_FOREST = 0.7;
 }
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 var numForest = totalTrees * P_FOREST;
 var numStragglers = totalTrees * (1.0 - P_FOREST);
 
 log("Creating forests...");
 var types = [
 	[[tForestFloor2, tMainTerrain, pForest1], [tForestFloor2, pForest1]],
 	[[tForestFloor1, tMainTerrain, pForest2], [tForestFloor1, pForest2]]
 ];	// some variation
 
 if (currentBiome() != "savanna")
 {
 	var size = numForest / (scaleByMapSize(3,6) * numPlayers);
 	var num = floor(size / types.length);
 	for (var i = 0; i < types.length; ++i)
 	{
 		placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), numForest / (num * floor(scaleByMapSize(2,5))), 0.5);
 		painter = new LayeredPainter(
 			types[i],		// terrains
 			[2]											// widths
 			);
 		createAreas(
 			placer,
 			[painter, paintClass(clForest)],
 			[avoidClasses(clPlayer, 0, clForest, 10, clHill, 0), stayClasses(clLand, 6)],
 			num
 		);
 	}
 }
 
 RMS.SetProgress(50);
 log("Creating dirt patches...");
 var sizes = [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)];
 var numb = 1;
 if (currentBiome() == "savanna")
 	numb = 3;
 for (var i = 0; i < sizes.length; i++)
 {
 	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
 	painter = new LayeredPainter(
 		[[tMainTerrain,tTier1Terrain],[tTier1Terrain,tTier2Terrain], [tTier2Terrain,tTier3Terrain]], 		// terrains
 		[1,1]															// widths
 	);
 	createAreas(
 		placer,
 		[painter, paintClass(clDirt)],
 		[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 0), stayClasses(clLand, 6)],
 		numb*scaleByMapSize(15, 45)
 	);
 }
 
 log("Creating grass patches...");
 var sizes = [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)];
 for (var i = 0; i < sizes.length; i++)
 {
 	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
 	painter = new 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...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 0, clRock, 10, clHill, 1), stayClasses(clLand, 5)],
 	scaleByMapSize(4,16), 100
 );
 
 log("Creating small stone quarries...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 0, clRock, 10, clHill, 1), stayClasses(clLand, 5)],
 	scaleByMapSize(4,16), 100
 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 0, clMetal, 10, clRock, 5, clHill, 1), stayClasses(clLand, 5)],
 	scaleByMapSize(4,16), 100
 );
 
 RMS.SetProgress(65);
 
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockMedium, 1,3, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 5)],
 	scaleByMapSize(16, 262), 50
 );
 
 log("Creating large decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 5)],
 	scaleByMapSize(8, 131), 50
 );
 
 RMS.SetProgress(70);
 
 log("Creating deer...");
 group = new SimpleGroup(
 	[new SimpleObject(oMainHuntableAnimal, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 0, clHill, 1, clFood, 20), stayClasses(clLand, 5)],
 	3 * numPlayers, 50
 );
 
 RMS.SetProgress(75);
 
 log("Creating sheep...");
 group = new SimpleGroup(
 	[new SimpleObject(oSecondaryHuntableAnimal, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 0, clHill, 1, clFood, 20), stayClasses(clLand, 5)],
 	3 * numPlayers, 50
 );
 
 log("Creating fruit bush...");
 group = new SimpleGroup(
 	[new SimpleObject(oFruitBush, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 8, clHill, 1, clFood, 20), stayClasses(clLand, 5)],
 	randIntInclusive(1, 4) * numPlayers + 2, 50
 );
 
 log("Creating fish...");
 group = new SimpleGroup(
 	[new SimpleObject(oFish, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clLand, 4, clForest, 2, clPlayer, 2, clHill, 2, clFood, 20),
 	25 * numPlayers, 60
 );
 
 RMS.SetProgress(85);
 
 log("Creating straggler trees...");
 var types = [oTree1, oTree2, oTree4, oTree3];	// some variation
 var num = floor(numStragglers / types.length);
 for (var i = 0; i < types.length; ++i)
 {
 	group = new SimpleGroup(
 		[new SimpleObject(types[i], 1,1, 0,3)],
 		true, clForest
 	);
 	createObjectGroupsDeprecated(group, 0,
 		[avoidClasses(clForest, 1, clHill, 1, clPlayer, 0, clMetal, 6, clRock, 6), stayClasses(clLand, 6)],
 		num
 	);
 }
 
 var planetm = 1;
 if (currentBiome() == "tropic")
 	planetm = 8;
 
 log("Creating small grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)]
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clHill, 2, clPlayer, 2, clDirt, 0), stayClasses(clLand, 6)],
 	planetm * scaleByMapSize(13, 200)
 );
 
 RMS.SetProgress(90);
 
 log("Creating large grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aGrass, 2,4, 0,1.8, -PI/8,PI/8), new SimpleObject(aGrassShort, 3,6, 1.2,2.5, -PI/8,PI/8)]
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clHill, 2, clPlayer, 2, clDirt, 1, clForest, 0), stayClasses(clLand, 5)],
 	planetm * scaleByMapSize(13, 200)
 );
 
 RMS.SetProgress(95);
 
 log("Creating bushes...");
 group = new SimpleGroup(
 	[new SimpleObject(aBushMedium, 1,2, 0,2), new SimpleObject(aBushSmall, 2,4, 0,2)]
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clHill, 1, clPlayer, 1, clDirt, 1), stayClasses(clLand, 6)],
 	planetm * scaleByMapSize(13, 200), 50
 );
 
 setSkySet(pickRandom(["cirrus", "cumulus", "sunny"]));
 setSunRotation(randFloat(0, TWO_PI));
 setSunElevation(randFloat(PI/ 5, PI / 3));
 setWaterWaviness(2);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/lake.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/lake.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/lake.js	(revision 20149)
@@ -1,331 +1,318 @@
 RMS.LoadLibrary("rmgen");
 RMS.LoadLibrary("rmbiome");
 
 setSelectedBiome();
 
 const tMainTerrain = g_Terrains.mainTerrain;
 const tForestFloor1 = g_Terrains.forestFloor1;
 const tForestFloor2 = g_Terrains.forestFloor2;
 const tCliff = g_Terrains.cliff;
 const tTier1Terrain = g_Terrains.tier1Terrain;
 const tTier2Terrain = g_Terrains.tier2Terrain;
 const tTier3Terrain = g_Terrains.tier3Terrain;
 const tHill = g_Terrains.hill;
 const tDirt = g_Terrains.dirt;
 const tRoad = g_Terrains.road;
 const tRoadWild = g_Terrains.roadWild;
 const tTier4Terrain = g_Terrains.tier4Terrain;
 const tShoreBlend = g_Terrains.shoreBlend;
 const tShore = g_Terrains.shore;
 const tWater = g_Terrains.water;
 
 const oTree1 = g_Gaia.tree1;
 const oTree2 = g_Gaia.tree2;
 const oTree3 = g_Gaia.tree3;
 const oTree4 = g_Gaia.tree4;
 const oTree5 = g_Gaia.tree5;
 const oFruitBush = g_Gaia.fruitBush;
 const oMainHuntableAnimal = g_Gaia.mainHuntableAnimal;
 const oFish = g_Gaia.fish;
 const oSecondaryHuntableAnimal = g_Gaia.secondaryHuntableAnimal;
 const oStoneLarge = g_Gaia.stoneLarge;
 const oStoneSmall = g_Gaia.stoneSmall;
 const oMetalLarge = g_Gaia.metalLarge;
 
 const aGrass = g_Decoratives.grass;
 const aGrassShort = g_Decoratives.grassShort;
 const aReeds = g_Decoratives.reeds;
 const aLillies = g_Decoratives.lillies;
 const aRockLarge = g_Decoratives.rockLarge;
 const aRockMedium = g_Decoratives.rockMedium;
 const aBushMedium = g_Decoratives.bushMedium;
 const aBushSmall = g_Decoratives.bushSmall;
 
 const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
 const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 const mapArea = mapSize*mapSize;
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clSettlement = createTileClass();
 
 initTerrain(tMainTerrain);
 
-var playerIDs = sortAllPlayers();
-
-// 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 [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 	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);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oFruitBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 		mAngle = randFloat(0, TWO_PI);
 
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var num = 5;
 	var tAngle = randFloat(0, TWO_PI);
 	var tDist = randFloat(12, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oTree1, num, num, 0,3)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 
 RMS.SetProgress(20);
 
 //create the lake
 var fx = fractionToTiles(0.5);
 var fz = fractionToTiles(0.5);
 ix = round(fx);
 iz = round(fz);
 
 const lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 6))));
 
 var placer = new ChainPlacer(2, floor(scaleByMapSize(5, 16)), floor(scaleByMapSize(35, 200)), 1, ix, iz, 0, [floor(mapSize * 0.17 * lSize)]);
 var terrainPainter = new LayeredPainter(
 	[tShore, tWater, tWater, tWater],		// terrains
 	[1, 4, 2]		// widths
 );
 var elevationPainter = new SmoothElevationPainter(
 	ELEVATION_SET,			// type
 	-3,				// elevation
 	4				// blend radius
 );
 createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 20));
 
 log("Creating more shore jaggedness...");
 
 placer = new ChainPlacer(2, floor(scaleByMapSize(4, 6)), 3, 1);
 terrainPainter = new LayeredPainter(
 	[tCliff, tHill],		// terrains
 	[2]								// widths
 );
 elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 4);
 createAreas(
 	placer,
 	[terrainPainter, elevationPainter, unPaintClass(clWater)],
 	borderClasses(clWater, 4, 7),
 	scaleByMapSize(12, 130) * 2, 150
 );
 
 paintTerrainBasedOnHeight(2.4, 3.4, 3, tMainTerrain);
 paintTerrainBasedOnHeight(1, 2.4, 0, tShore);
 paintTerrainBasedOnHeight(-8, 1, 2, tWater);
 paintTileClassBasedOnHeight(-6, 0, 1, clWater);
 
 for (var i = 0; i < numPlayers; ++i)
 {
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	var placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tRoadWild, tRoad], [1]);
 	createArea(placer, painter, null);
 }
 
 createBumps(avoidClasses(clWater, 2, clPlayer, 20));
 
 if (randBool())
 	createHills([tMainTerrain, tCliff, tHill], avoidClasses(clPlayer, 20, clHill, 15, clWater, 2), clHill, scaleByMapSize(1, 4) * numPlayers);
 else
 	createMountains(tCliff, avoidClasses(clPlayer, 20, clHill, 15, clWater, 2), clHill, scaleByMapSize(1, 4) * numPlayers);
 
 createForests(
  [tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
  avoidClasses(clPlayer, 20, clForest, 17, clHill, 0, clWater, 2),
  clForest,
  1,
  ...rBiomeTreeCount(1));
 
 RMS.SetProgress(50);
 
 log("Creating dirt patches...");
 createLayeredPatches(
  [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
  [[tMainTerrain,tTier1Terrain],[tTier1Terrain,tTier2Terrain], [tTier2Terrain,tTier3Terrain]],
  [1,1],
  avoidClasses(clWater, 3, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12)
 );
 
 log("Creating grass patches...");
 createPatches(
  [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
  tTier4Terrain,
  avoidClasses(clWater, 3, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12)
 );
 
 RMS.SetProgress(55);
 
 log("Creating stone mines...");
 createMines(
  [
   [new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)],
   [new SimpleObject(oStoneSmall, 2,5, 1,3)]
  ],
  avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clRock, 10, clHill, 1)
 );
 
 log("Creating metal mines...");
 createMines(
  [
   [new SimpleObject(oMetalLarge, 1,1, 0,4)]
  ],
  avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 1),
  clMetal
 );
 
 RMS.SetProgress(65);
 
 var planetm = 1;
 
 if (currentBiome() == "tropic")
 	planetm = 8;
 
 createDecoration
 (
  [[new SimpleObject(aRockMedium, 1,3, 0,1)],
   [new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
   [new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)],
   [new SimpleObject(aGrass, 2,4, 0,1.8, -PI/8,PI/8), new SimpleObject(aGrassShort, 3,6, 1.2,2.5, -PI/8,PI/8)],
   [new SimpleObject(aBushMedium, 1,2, 0,2), new SimpleObject(aBushSmall, 2,4, 0,2)]
  ],
  [
   scaleByMapSize(16, 262),
   scaleByMapSize(8, 131),
   planetm * scaleByMapSize(13, 200),
   planetm * scaleByMapSize(13, 200),
   planetm * scaleByMapSize(13, 200)
  ],
  avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0)
 );
 
 RMS.SetProgress(70);
 
 createFood
 (
  [
   [new SimpleObject(oMainHuntableAnimal, 5,7, 0,4)],
   [new SimpleObject(oSecondaryHuntableAnimal, 2,3, 0,2)]
  ],
  [
   3 * numPlayers,
   3 * numPlayers
  ],
  avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 20)
 );
 
 createFood
 (
  [
   [new SimpleObject(oFruitBush, 5,7, 0,4)]
  ],
  [
   3 * numPlayers
  ],
  avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 10)
 );
 
 createFood
 (
  [
   [new SimpleObject(oFish, 2,3, 0,2)]
  ],
  [
   25 * numPlayers
  ],
  [avoidClasses(clFood, 20), stayClasses(clWater, 6)]
 );
 
 RMS.SetProgress(85);
 
 var types = [oTree1, oTree2, oTree4, oTree3];	// some variation
 createStragglerTrees(types, avoidClasses(clWater, 5, clForest, 7, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6));
 setWaterWaviness(4.0);
 setWaterType("lake");
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/mainland.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/mainland.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/mainland.js	(revision 20149)
@@ -1,265 +1,253 @@
 RMS.LoadLibrary("rmgen");
 RMS.LoadLibrary("rmbiome");
 
 setSelectedBiome();
 
 const tMainTerrain = g_Terrains.mainTerrain;
 const tForestFloor1 = g_Terrains.forestFloor1;
 const tForestFloor2 = g_Terrains.forestFloor2;
 const tCliff = g_Terrains.cliff;
 const tTier1Terrain = g_Terrains.tier1Terrain;
 const tTier2Terrain = g_Terrains.tier2Terrain;
 const tTier3Terrain = g_Terrains.tier3Terrain;
 const tHill = g_Terrains.hill;
 const tDirt = g_Terrains.dirt;
 const tRoad = g_Terrains.road;
 const tRoadWild = g_Terrains.roadWild;
 const tTier4Terrain = g_Terrains.tier4Terrain;
 const tShoreBlend = g_Terrains.shoreBlend;
 const tShore = g_Terrains.shore;
 const tWater = g_Terrains.water;
 
 const oTree1 = g_Gaia.tree1;
 const oTree2 = g_Gaia.tree2;
 const oTree3 = g_Gaia.tree3;
 const oTree4 = g_Gaia.tree4;
 const oTree5 = g_Gaia.tree5;
 const oFruitBush = g_Gaia.fruitBush;
 const oMainHuntableAnimal = g_Gaia.mainHuntableAnimal;
 const oFish = g_Gaia.fish;
 const oSecondaryHuntableAnimal = g_Gaia.secondaryHuntableAnimal;
 const oStoneLarge = g_Gaia.stoneLarge;
 const oStoneSmall = g_Gaia.stoneSmall;
 const oMetalLarge = g_Gaia.metalLarge;
 
 const aGrass = g_Decoratives.grass;
 const aGrassShort = g_Decoratives.grassShort;
 const aReeds = g_Decoratives.reeds;
 const aLillies = g_Decoratives.lillies;
 const aRockLarge = g_Decoratives.rockLarge;
 const aRockMedium = g_Decoratives.rockMedium;
 const aBushMedium = g_Decoratives.bushMedium;
 const aBushSmall = g_Decoratives.bushSmall;
 
 const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
 const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 const mapArea = mapSize*mapSize;
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clSettlement = createTileClass();
 
 initTerrain(tMainTerrain);
 
-var playerIDs = sortAllPlayers();
-
-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 [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 	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);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	var placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tRoadWild, tRoad], [1]);
 	createArea(placer, painter, null);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oFruitBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var num = 5;
 	var tAngle = randFloat(0, TWO_PI);
 	var tDist = randFloat(12, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oTree1, num, num, 0,3)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 RMS.SetProgress(20);
 
 createBumps();
 
 if (randBool())
 	createHills([tCliff, tCliff, tHill], avoidClasses(clPlayer, 20, clHill, 15), clHill, scaleByMapSize(3, 15));
 else
 	createMountains(tCliff, avoidClasses(clPlayer, 20, clHill, 15), clHill, scaleByMapSize(3, 15));
 
 createForests(
  [tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
  avoidClasses(clPlayer, 20, clForest, 18, clHill, 0),
  clForest,
  1,
  ...rBiomeTreeCount(1));
 
 RMS.SetProgress(50);
 
 log("Creating dirt patches...");
 createLayeredPatches(
  [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
  [[tMainTerrain,tTier1Terrain],[tTier1Terrain,tTier2Terrain], [tTier2Terrain,tTier3Terrain]],
  [1,1]
 );
 
 log("Creating grass patches...");
 createPatches(
  [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
  tTier4Terrain
 );
 
 RMS.SetProgress(55);
 
 log("Creating stone mines...");
 createMines(
  [
   [new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)],
   [new SimpleObject(oStoneSmall, 2,5, 1,3)]
  ]
 );
 
 log("Creating metal mines...");
 createMines(
  [
   [new SimpleObject(oMetalLarge, 1,1, 0,4)]
  ],
  avoidClasses(clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 1),
  clMetal
 );
 
 RMS.SetProgress(65);
 
 var planetm = 1;
 
 if (currentBiome() == "tropic")
 	planetm = 8;
 
 createDecoration
 (
  [[new SimpleObject(aRockMedium, 1,3, 0,1)],
   [new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
   [new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)],
   [new SimpleObject(aGrass, 2,4, 0,1.8, -PI/8,PI/8), new SimpleObject(aGrassShort, 3,6, 1.2,2.5, -PI/8,PI/8)],
   [new SimpleObject(aBushMedium, 1,2, 0,2), new SimpleObject(aBushSmall, 2,4, 0,2)]
  ],
  [
   scaleByMapSize(16, 262),
   scaleByMapSize(8, 131),
   planetm * scaleByMapSize(13, 200),
   planetm * scaleByMapSize(13, 200),
   planetm * scaleByMapSize(13, 200)
  ]
 );
 
 RMS.SetProgress(70);
 
 createFood
 (
  [
   [new SimpleObject(oMainHuntableAnimal, 5,7, 0,4)],
   [new SimpleObject(oSecondaryHuntableAnimal, 2,3, 0,2)]
  ],
  [
   3 * numPlayers,
   3 * numPlayers
  ]
 );
 
 RMS.SetProgress(75);
 
 createFood
 (
  [
   [new SimpleObject(oFruitBush, 5,7, 0,4)]
  ],
  [
   3 * numPlayers
  ],
  avoidClasses(clForest, 0, clPlayer, 20, clHill, 1, clFood, 10)
 );
 
 RMS.SetProgress(85);
 
 var types = [oTree1, oTree2, oTree4, oTree3];	// some variation
 createStragglerTrees(types);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/neareastern_badlands.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/neareastern_badlands.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/neareastern_badlands.js	(revision 20149)
@@ -1,413 +1,400 @@
 RMS.LoadLibrary("rmgen");
 
 const tCity = "desert_city_tile";
 const tCityPlaza = "desert_city_tile_plaza";
 const tSand = "desert_dirt_rough";
 const tDunes = "desert_sand_dunes_100";
 const tFineSand = "desert_sand_smooth";
 const tCliff = ["desert_cliff_badlands", "desert_cliff_badlands_2"];
 const tForestFloor = "desert_forestfloor_palms";
 const tGrass = "desert_grass_a";
 const tGrassSand50 = "desert_grass_a_sand";
 const tGrassSand25 = "desert_grass_a_stones";
 const tDirt = "desert_dirt_rough";
 const tDirtCracks = "desert_dirt_cracks";
 const tShore = "desert_shore_stones";
 const tWaterDeep = "desert_shore_stones_wet";
 
 const oBerryBush = "gaia/flora_bush_grapes";
 const oCamel = "gaia/fauna_camel";
 const oFish = "gaia/fauna_fish";
 const oGazelle = "gaia/fauna_gazelle";
 const oGiraffe = "gaia/fauna_giraffe";
 const oGoat = "gaia/fauna_goat";
 const oWildebeest = "gaia/fauna_wildebeest";
 const oStoneLarge = "gaia/geology_stonemine_desert_badlands_quarry";
 const oStoneSmall = "gaia/geology_stone_desert_small";
 const oMetalLarge = "gaia/geology_metal_desert_slabs";
 const oDatePalm = "gaia/flora_tree_date_palm";
 const oSDatePalm = "gaia/flora_tree_senegal_date_palm";
 
 const aBush1 = "actor|props/flora/bush_desert_a.xml";
 const aBush2 = "actor|props/flora/bush_desert_dry_a.xml";
 const aBush3 = "actor|props/flora/bush_dry_a.xml";
 const aBush4 = "actor|props/flora/plant_desert_a.xml";
 const aBushes = [aBush1, aBush2, aBush3, aBush4];
 const aDecorativeRock = "actor|geology/stone_desert_med.xml";
 
 // terrain + entity (for painting)
 const pForest = [tForestFloor + TERRAIN_SEPARATOR + oDatePalm, tForestFloor + TERRAIN_SEPARATOR + oSDatePalm, tForestFloor];
 const pForestOasis = [tGrass + TERRAIN_SEPARATOR + oDatePalm, tGrass + TERRAIN_SEPARATOR + oSDatePalm, tGrass];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 const mapArea = mapSize*mapSize;
 
 var clPlayer = createTileClass();
 var clHill1 = createTileClass();
 var clHill2 = createTileClass();
 var clHill3 = createTileClass();
 var clForest = createTileClass();
 var clPatch = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 
-var playerIDs = sortAllPlayers();
-
-// 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]);
-}
+var [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	// scale radius of player area by map size
 	var radius = scaleByMapSize(15,25);
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 
 	// calculate size based on the radius
 	var size = PI * radius * radius;
 
 	// create the player area
 	var placer = new ClumpPlacer(size, 0.9, 0.5, 10, ix, iz);
 	createArea(placer, paintClass(clPlayer), null);
 
 	// create the city patch
 	var cityRadius = 10;
 	placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tCity, tCityPlaza], [3]);
 	createArea(placer, painter, null);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oBerryBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 		mAngle = randFloat(0, TWO_PI);
 
 	var mDist = 11;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0), new RandomObject(aBushes, 2,4, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2), new RandomObject(aBushes, 2,4, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	var hillSize = PI * radius * radius;
 	// create starting trees
 	var num = floor(hillSize / 100);
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(12, 14);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oDatePalm, num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 }
 RMS.SetProgress(10);
 
 log("Creating dune patches...");
 placer = new ClumpPlacer(scaleByMapSize(40, 150), 0.2, 0.1, 0);
 painter = new TerrainPainter(tDunes);
 createAreas(placer, [painter, paintClass(clPatch)],
 	avoidClasses(clPatch, 2, clPlayer, 0),
 	scaleByMapSize(5, 20)
 );
 RMS.SetProgress(15);
 
 log("Creating sand patches...");
 var placer = new ClumpPlacer(scaleByMapSize(25, 100), 0.2, 0.1, 0);
 var painter = new TerrainPainter([tSand, tFineSand]);
 createAreas(placer, [painter, paintClass(clPatch)],
 	avoidClasses(clPatch, 2, clPlayer, 0),
 	scaleByMapSize(15, 50)
 );
 RMS.SetProgress(20);
 
 log("Creating dirt patches...");
 placer = new ClumpPlacer(scaleByMapSize(25, 100), 0.2, 0.1, 0);
 painter = new TerrainPainter([tDirt]);
 createAreas(placer, [painter, paintClass(clPatch)],
 	avoidClasses(clPatch, 2, clPlayer, 0),
 	scaleByMapSize(15, 50)
 );
 RMS.SetProgress(25);
 
 log("Creating oasis...");
 var oRadius = scaleByMapSize(14, 40);
 placer = new ClumpPlacer(PI*oRadius*oRadius, 0.6, 0.15, 0, mapSize/2, mapSize/2);
 painter = new LayeredPainter([[tSand, pForest], [tGrassSand25, pForestOasis], tGrassSand25, tShore, tWaterDeep], [2, 3, 1, 1]);
 elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, -11, 8);
 createArea(placer, [painter, elevationPainter, paintClass(clForest)], null);
 RMS.SetProgress(30);
 
 log("Creating oasis wildlife...");
 var num = round(PI * oRadius / 8);
 var constraint = new AndConstraint([borderClasses(clForest, 0, 3), avoidClasses(clForest, 0)]);
 var halfSize = mapSize/2;
 for (var i = 0; i < num; ++i)
 {
 	var r = 0;
 	var angle = TWO_PI / num * i;
 	do {
 		// Work outward until constraint met
 		var gx = round(halfSize + r * cos(angle));
 		var gz = round(halfSize + r * sin(angle));
 		++r;
 	} while (!constraint.allows(gx,gz) && r < halfSize);
 
 	group = new RandomGroup(
 		[	new SimpleObject(oGiraffe, 2,4, 0,3),		// select from these groups randomly
 			new SimpleObject(oWildebeest, 3,5, 0,3),
 			new SimpleObject(oGazelle, 5,7, 0,3)
 		], true, clFood, gx, gz
 	);
 	createObjectGroup(group, 0);
 }
 
 constraint = new AndConstraint([borderClasses(clForest, 15, 0), avoidClasses(clFood, 5)]);
 num = round(PI * oRadius / 16);
 for (var i = 0; i < num; ++i)
 {
 	var r = 0;
 	var angle = TWO_PI / num * i;
 	do {
 		// Work outward until constraint met
 		var gx = round(halfSize + r * cos(angle));
 		var gz = round(halfSize + r * sin(angle));
 		++r;
 	} while (!constraint.allows(gx,gz) && r < halfSize);
 
 	group = new SimpleGroup(
 		[new SimpleObject(oFish, 1,1, 0,1)],
 		true, clFood, gx, gz
 	);
 	createObjectGroup(group, 0);
 }
 RMS.SetProgress(35);
 
 log("Creating level 1 hills...");
 placer = new ClumpPlacer(scaleByMapSize(50,300), 0.25, 0.1, 0.5);
 var terrainPainter = new LayeredPainter(
 	[tCliff, tSand],		// terrains
 	[1]				// widths
 );
 var elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, 16, 1);
 var hillAreas = createAreas(placer, [terrainPainter, elevationPainter, paintClass(clHill1)],
 	avoidClasses(clForest, 3, clPlayer, 0, clHill1, 10),
 	scaleByMapSize(10,20), 100
 );
 RMS.SetProgress(40);
 
 log("Creating small level 1 hills...");
 placer = new ClumpPlacer(scaleByMapSize(25,150), 0.25, 0.1, 0.5);
 terrainPainter = new LayeredPainter(
 	[tCliff, tSand],		// terrains
 	[1]				// widths
 );
 elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, 16, 1);
 var tempAreas = createAreas(placer, [terrainPainter, elevationPainter, paintClass(clHill1)],
 	avoidClasses(clForest, 3, clPlayer, 0, clHill1, 3),
 	scaleByMapSize(15,25), 100
 );
 for (var i = 0; i < tempAreas.length; ++i)
 	hillAreas.push(tempAreas[i]);
 RMS.SetProgress(45);
 
 log("Creating decorative rocks...");
 group = new SimpleGroup(
 	[new RandomObject([aDecorativeRock, aBush2, aBush3], 3,8, 0,2)],
 	true
 );
 createObjectGroupsByAreasDeprecated(group, 0,
 	borderClasses(clHill1, 0, 3),
 	scaleByMapSize(40,200), 50,
 	hillAreas
 );
 
 RMS.SetProgress(50);
 
 log("Creating level 2 hills...");
 placer = new ClumpPlacer(scaleByMapSize(25,150), 0.25, 0.1, 0);
 terrainPainter = new LayeredPainter(
 	[tCliff, tSand],		// terrains
 	[1]				// widths
 );
 elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, 16, 1);
 createAreasInAreas(placer, [terrainPainter, elevationPainter],
 	[stayClasses(clHill1, 0)],
 	scaleByMapSize(15,25), 50,
 	hillAreas
 );
 RMS.SetProgress(55);
 
 log("Creating level 3 hills...");
 placer = new ClumpPlacer(scaleByMapSize(12, 75), 0.25, 0.1, 0);
 terrainPainter = new LayeredPainter(
 	[tCliff, tSand],		// terrains
 	[1]				// widths
 );
 elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, 16, 1);
 createAreas(placer, [terrainPainter, elevationPainter],
 	[stayClasses(clHill1, 0)],
 	scaleByMapSize(15,25), 50
 );
 RMS.SetProgress(60);
 
 log("Creating bumps...");
 placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 0);
 elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2);
 createAreas(
 	placer,
 	elevationPainter,
 	avoidClasses(clForest, 0, clPlayer, 0, clHill1, 2),
 	scaleByMapSize(100, 200)
 );
 
 RMS.SetProgress(65);
 
 // calculate desired number of trees for map (based on size)
 const MIN_TREES = 500;
 const MAX_TREES = 2500;
 const P_FOREST = 0.5;
 
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 var numForest = totalTrees * P_FOREST;
 var numStragglers = totalTrees * (1.0 - P_FOREST);
 
 log("Creating forests...");
 var num = scaleByMapSize(10,30);
 placer = new ClumpPlacer(numForest / num, 0.15, 0.1, 0.5);
 painter = new TerrainPainter([tSand, pForest]);
 createAreas(placer, [painter, paintClass(clForest)],
 	avoidClasses(clPlayer, 1, clForest, 10, clHill1, 1),
 	num, 50
 );
 
 RMS.SetProgress(70);
 
 log("Creating stone mines...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4), new RandomObject(aBushes, 2,4, 0,2)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 10, clRock, 10, clHill1, 1)],
 	scaleByMapSize(4,16), 100
 );
 
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3), new RandomObject(aBushes, 2,4, 0,2)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 10, clRock, 10, clHill1, 1)],
 	scaleByMapSize(4,16), 100
 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4), new RandomObject(aBushes, 2,4, 0,2)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 10, clMetal, 10, clRock, 5, clHill1, 1)],
 	scaleByMapSize(4,16), 100
 );
 
 RMS.SetProgress(80);
 
 log("Creating gazelles...");
 group = new SimpleGroup([new SimpleObject(oGazelle, 5,7, 0,4)], true, clFood);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 5, clHill1, 1, clFood, 10),
 	scaleByMapSize(5,20), 50
 );
 
 log("Creating goats...");
 group = new SimpleGroup([new SimpleObject(oGoat, 2,4, 0,3)], true, clFood);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 5, clHill1, 1, clFood, 10),
 	scaleByMapSize(5,20), 50
 );
 
 log("Creating camels...");
 group = new SimpleGroup([new SimpleObject(oCamel, 2,4, 0,2)], true, clFood);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 5, clHill1, 1, clFood, 10),
 	scaleByMapSize(5,20), 50
 );
 RMS.SetProgress(85);
 
 log("Creating straggler trees...");
 var types = [oDatePalm, oSDatePalm];	// some variation
 var num = floor(numStragglers / types.length);
 for (var i = 0; i < types.length; ++i)
 {
 	group = new SimpleGroup([new SimpleObject(types[i], 1,1, 0,0)], true);
 	createObjectGroupsDeprecated(group, 0,
 		avoidClasses(clForest, 0, clHill1, 1, clPlayer, 4, clMetal, 6, clRock, 6),
 		num
 	);
 }
 RMS.SetProgress(90);
 
 log("Creating bushes...");
 group = new SimpleGroup([new RandomObject(aBushes, 2,3, 0,2)]);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clHill1, 1, clPlayer, 0, clForest, 0),
 	scaleByMapSize(16, 262)
 );
 
 log("Creating more decorative rocks...");
 group = new SimpleGroup([new SimpleObject(aDecorativeRock, 1,2, 0,2)]);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clHill1, 1, clPlayer, 0, clForest, 0),
 	scaleByMapSize(16, 262)
 );
 
 setWaterColor(0, 0.227, 0.843);
 setWaterTint(0, 0.545, 0.859);
 setWaterWaviness(1.0);
 setWaterType("clap");
 setWaterMurkiness(0.75);
 setWaterHeight(20);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/new_rms_test.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/new_rms_test.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/new_rms_test.js	(revision 20149)
@@ -1,44 +1,32 @@
 RMS.LoadLibrary("rmgen");
 
 InitMap();
 
 var numPlayers = getNumPlayers();
 var mapSize = getMapSize();
 
 var clPlayer = createTileClass();
 var clPath = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clRock = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 
-var playerIDs = sortAllPlayers();
-
-var playerX = new Array(numPlayers);
-var playerZ = new Array(numPlayers);
-var playerAngle = new Array(numPlayers);
-
-var startAngle = randFloat(0, 2 * PI);
-for (var i=0; i < numPlayers; i++)
-{
-	playerAngle[i] = startAngle + i*2*PI/numPlayers;
-	playerX[i] = 0.5 + 0.39*cos(playerAngle[i]);
-	playerZ[i] = 0.5 + 0.39*sin(playerAngle[i]);
-}
+var [playerIDs, playerX, playerZ] = radialPlayerPlacement(0.39);
 
 for (var i=0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 
 	placeCivDefaultEntities(fx, fz, id);
 }
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/oasis.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/oasis.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/oasis.js	(revision 20149)
@@ -1,368 +1,356 @@
 RMS.LoadLibrary("rmgen");
 
 const tSand = ["desert_sand_dunes_100", "desert_dirt_cracks","desert_sand_smooth", "desert_dirt_rough", "desert_dirt_rough_2", "desert_sand_smooth"];
 const tDune = ["desert_sand_dunes_50"];
 const tBigDune = ["desert_sand_dunes_50"];
 const tForestFloor = "desert_forestfloor_palms";
 const tHill = ["desert_dirt_rocks_1", "desert_dirt_rocks_2", "desert_dirt_rocks_3"];
 const tDirt = ["desert_dirt_rough","desert_dirt_rough","desert_dirt_rough", "desert_dirt_rough_2", "desert_dirt_rocks_2"];
 const tRoad = "desert_city_tile";;
 const tRoadWild = "desert_city_tile";;
 const tShoreBlend = "desert_sand_wet";
 const tShore = "dirta";
 const tWater = "desert_sand_wet";
 
 const ePalmShort = "gaia/flora_tree_cretan_date_palm_short";
 const ePalmTall = "gaia/flora_tree_cretan_date_palm_tall";
 const eBush = "gaia/flora_bush_grapes";
 const eCamel = "gaia/fauna_camel";
 const eGazelle = "gaia/fauna_gazelle";
 const eLion = "gaia/fauna_lion";
 const eLioness = "gaia/fauna_lioness";
 const eStoneMine = "gaia/geology_stonemine_desert_quarry";
 const eStoneMineSmall = "gaia/geology_stone_desert_small";
 const eMetalMine = "gaia/geology_metal_desert_slabs";
 
 const aFlower1 = "actor|props/flora/decals_flowers_daisies.xml";
 const aWaterFlower = "actor|props/flora/water_lillies.xml";
 const aReedsA = "actor|props/flora/reeds_pond_lush_a.xml";
 const aReedsB = "actor|props/flora/reeds_pond_lush_b.xml";
 const aRock = "actor|geology/stone_desert_med.xml";
 const aBushA = "actor|props/flora/bush_desert_dry_a.xml";
 const aBushB = "actor|props/flora/bush_desert_dry_a.xml";
 const aSand = "actor|particle/blowing_sand.xml";
 
 const pForestMain = [tForestFloor + TERRAIN_SEPARATOR + ePalmShort, tForestFloor + TERRAIN_SEPARATOR + ePalmTall, tForestFloor];
 const pOasisForestLight = [tForestFloor + TERRAIN_SEPARATOR + ePalmShort, tForestFloor + TERRAIN_SEPARATOR + ePalmTall, tForestFloor,tForestFloor,tForestFloor
 					,tForestFloor,tForestFloor,tForestFloor,tForestFloor];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 const mapArea = mapSize*mapSize;
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clPassage = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clSettlement = createTileClass();
 var clDune = createTileClass();
 
 initTerrain(tSand);
 
-var playerIDs = sortAllPlayers();
+var [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
-// 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 placer = undefined;
 var fx = 0; var fz = 0;
 var ix =0; var iz = 0;
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var elevation = 20;
 
 	// get the x and z in tiles
 	fx = fractionToTiles(playerX[i]);
 	fz = fractionToTiles(playerZ[i]);
 	ix = round(fx);
 	iz = round(fz);
 	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(eBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = radius*1.3;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(eMetalMine, 1,1, 0,0),new SimpleObject(aBushB, 1,1, 2,2), new SimpleObject(aBushA, 0,2, 1,3),new SimpleObject(ePalmShort, 2,2, 2,3),new SimpleObject(ePalmTall, 1,1, 2,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 	mX = round(fx + mDist*1.5 * cos(mAngle + PI/1.578));
 	mZ = round(fz + mDist*1.5 * sin(mAngle + PI/1.578));
 	group = new SimpleGroup(
 							[new SimpleObject(eMetalMine, 1,1, 0,0),new SimpleObject(aBushB, 1,1, 2,2), new SimpleObject(aBushA, 0,2, 1,3),new SimpleObject(ePalmShort, 2,2, 2,3),new SimpleObject(ePalmTall, 1,1, 2,2)],
 							true, clBaseResource, mX, mZ
 							);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(eStoneMine, 1,1, 0,2),new SimpleObject(aBushB, 1,1, 2,2), new SimpleObject(aBushA, 0,2, 1,3),new SimpleObject(ePalmShort, 2,2, 2,3),new SimpleObject(ePalmTall, 1,1, 2,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 	mX = round(fx + mDist * 1.4 * cos(mAngle - PI /2.46));
 	mZ = round(fz + mDist * 1.4 * sin(mAngle - PI /2.46));
 	group = new SimpleGroup(
 							[new SimpleObject(eStoneMine, 1,1, 0,2),new SimpleObject(aBushB, 1,1, 2,2), new SimpleObject(aBushA, 0,2, 3,3),new SimpleObject(ePalmShort, 2,2, 3,3),new SimpleObject(ePalmTall, 1,1, 3,3)],
 							true, clBaseResource, mX, mZ
 							);
 	createObjectGroup(group, 0);
 	// Create starting batches of wood
 	var types = [tForestFloor, pForestMain];	// some variation
 	var forestX = 0;
 	var forestY = 0;
 	var forestAngle = 0;
 	do {
 		forestAngle = mAngle + randFloat(PI/2, (2*PI)/3);
 		var forestDist = radius * 1.2;
 		forestX = round(fx + forestDist * cos(forestAngle));
 		forestY = round(fz + forestDist * sin(forestAngle));
 		placer = new ClumpPlacer(70, 1.0, 0.5, 10,forestX,forestY);
 		painter = new LayeredPainter(types, [0] );
 	} while (createArea( placer, [painter, paintClass(clBaseResource)], avoidClasses(clBaseResource, 0) ) === undefined);
 	// creating the water patch explaining the forest
 	do {
 		var watAngle = forestAngle + randFloat((PI/3), (5*PI/3));
 		var watX = round(forestX + 6 * cos(watAngle));
 		var watY = round(forestY + 6 * sin(watAngle));
 		placer = new ClumpPlacer(60, 0.9, 0.4, 5,watX,watY);
 		terrainPainter = new LayeredPainter( [tShore,tShoreBlend], [1] );
 		painter = new SmoothElevationPainter(ELEVATION_MODIFY, -5, 3);
 		group = new SimpleGroup( [new SimpleObject(aFlower1, 1,5, 0,3)], true, undefined, round(forestX + 3 * cos(watAngle)),round(forestY + 3 * sin(watAngle)) );
 		createObjectGroup(group, 0);
 		group = new SimpleGroup( [new SimpleObject(aReedsA, 1,3, 0,0)], true, undefined, round(forestX + 5 * cos(watAngle)),round(forestY + 5 * sin(watAngle)) );
 		createObjectGroup(group, 0);
 	} while (createArea( placer, [terrainPainter, painter],  avoidClasses(clBaseResource,0) ) === undefined);
 
 	// TODO: add a few random trees here and there
 }
 RMS.SetProgress(20);
 
 log("Creating bumps...");
 placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1);
 painter = new SmoothElevationPainter(ELEVATION_MODIFY, 4, 3);
 createAreas( placer, painter,
 			avoidClasses(clPlayer, 10, clBaseResource, 6),
 			scaleByMapSize(30, 70)
 			);
 log("Creating dirt Patches...");
 placer = new ClumpPlacer(80, 0.3, 0.06, 1);
 var terrainPainter = new TerrainPainter(tDirt);
 createAreas(placer, terrainPainter, avoidClasses(clPlayer, 10, clBaseResource, 6), scaleByMapSize(15, 50) );
 
 log("Creating Dunes...");
 placer = new ClumpPlacer(120, 0.3, 0.06, 1);
 var terrainPainter = new TerrainPainter(tDune);
 painter = new SmoothElevationPainter(ELEVATION_MODIFY, 18, 30);
 createAreas( placer, [terrainPainter, painter],
 			avoidClasses(clPlayer, 10, clBaseResource, 6),
 			scaleByMapSize(15, 50)
 			);
 
 log("Creating actual oasis...");
 var size = mapSize * 0.2;
 size *= size;
 //var lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 6))));
 fx = fractionToTiles(0.5);
 fz = fractionToTiles(0.5);
 ix = round(fx);
 iz = round(fz);
 placer = new ClumpPlacer(size*1.1, 0.8, 0.2, 10, ix, iz);
 terrainPainter = new LayeredPainter( [pOasisForestLight,tShoreBlend, tWater, tWater, tWater], [scaleByMapSize(6,20),3, 5, 2] );
 var elevationPainter = new SmoothElevationPainter(ELEVATION_SET,  -3,  15 );
 createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], null);
 RMS.SetProgress(50);
 if (mapSize > 150 && randBool())
 {
 	log ("creating path through");
 	var pAngle = randFloat(0, TWO_PI);
 	var px = round(fx) + round(fractionToTiles(0.13 * cos(pAngle)));
 	var py = round(fz) + round(fractionToTiles(0.13 * sin(pAngle)));
 	var pex = round(fx) + round(fractionToTiles(0.13 * -cos(pAngle)));
 	var pey = round(fz) + round(fractionToTiles(0.13 * sin(pAngle + PI)));
 	var path = new PathPlacer(px,py,pex,pey,scaleByMapSize(7,18), 0.4, 1, 0.2, 0);
 	terrainPainter = new TerrainPainter(tSand);
 	elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, 4, 5 );
 	createArea(path, [terrainPainter, elevationPainter, paintClass(clPassage)], null);
 }
 log("Creating some straggler trees around the Passage...");
 group = new SimpleGroup([new SimpleObject(ePalmTall, 1,1, 0,0),new SimpleObject(ePalmShort, 1,2, 1,2), new SimpleObject(aBushA, 0,2, 1,3)], true, clForest);
 createObjectGroupsDeprecated(group, 0, stayClasses(clPassage,1), scaleByMapSize(60,250), 100  );
 
 log("Creating stone mines...");
 group = new SimpleGroup([new SimpleObject(eStoneMine, 1,1, 0,0),new SimpleObject(ePalmShort, 1,2, 3,3),new SimpleObject(ePalmTall, 0,1, 3,3)
 						 ,new SimpleObject(aBushB, 1,1, 2,2), new SimpleObject(aBushA, 0,2, 1,3)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 10, clForest, 1, clPlayer, 30, clRock, 10,clBaseResource, 2, clHill, 1),
 	scaleByMapSize(6,25), 100
 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(eMetalMine, 1,1, 0,0),new SimpleObject(ePalmShort, 1,2, 2,3),new SimpleObject(ePalmTall, 0,1, 2,2)
 						 ,new SimpleObject(aBushB, 1,1, 2,2), new SimpleObject(aBushA, 0,2, 1,3)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 10, clForest, 1, clPlayer, 30, clMetal, 10,clBaseResource, 2, clRock, 10, clHill, 1),
 	scaleByMapSize(6,25), 100
 );
 RMS.SetProgress(65);
 
 log("Creating small decorative rocks...");
 group = new SimpleGroup( [new SimpleObject(aRock, 2,4, 0,2)], true, undefined );
 createObjectGroupsDeprecated(group, 0, avoidClasses(clWater, 3, clForest, 0, clPlayer, 10, clHill, 1, clFood, 20), 30, scaleByMapSize(10,50) );
 
 RMS.SetProgress(70);
 
 log("Creating Camels...");
 group = new SimpleGroup(
 	[new SimpleObject(eCamel, 1,2, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 0, clPlayer, 10, clHill, 1, clFood, 20),
 	1 * numPlayers, 50
 );
 RMS.SetProgress(75);
 
 log("Creating Gazelles...");
 group = new SimpleGroup(
 	[new SimpleObject(eGazelle, 2,4, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 0, clPlayer, 10, clHill, 1, clFood, 20),
 	1 * numPlayers, 50
 );
 RMS.SetProgress(85);
 
 log("Creating Oasis Animals...");
 for (var p = 0; p < scaleByMapSize(5,30); p++)
 {
 	fx = fractionToTiles(0.5);
 	fz = fractionToTiles(0.5);
 	var aAngle = randFloat(0, TWO_PI);
 	var aDist = fractionToTiles(0.11);
 	var animX = round(fx + aDist * cos(aAngle));
 	var animY = round(fz + aDist * sin(aAngle));
 	group = new RandomGroup(
 		[new SimpleObject(eLion, 1,2, 0,4),new SimpleObject(eLioness, 1,2, 2,4),new SimpleObject(eGazelle, 4,6, 1,5),new SimpleObject(eCamel, 1,2, 1,5)], true, clFood, animX,animY);
 	createObjectGroup(group, 0);
 }
 /*
 var planetm = 8;
 log("Creating small grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(rba1, 1,2, 0,1, -PI/8,PI/8)]
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 2, clHill, 2, clPlayer, 2, clDirt, 0),
 	planetm * scaleByMapSize(13, 200)
 );
 */
 RMS.SetProgress(90);
 
 RMS.SetProgress(95);
 
 log("Creating bushes...");
 group = new SimpleGroup(
 	[new SimpleObject(aBushB, 1,2, 0,2), new SimpleObject(aBushA, 2,4, 0,2)]
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 2, clHill, 1, clPlayer, 1, clPassage, 1),
 	scaleByMapSize(10, 40), 20
 );
 log ("Creating Sand blows and beautifications");
 for (var sandx = 0; sandx < mapSize; sandx += 4)
 	for (var sandz = 0; sandz < mapSize; sandz += 4)
 	{
 		if (getHeight(sandx,sandz) > 3.4)
 		{
 			if (randBool((getHeight(sandx,sandz) - 3.4) / 1.4))
 			{
 				group = new SimpleGroup( [new SimpleObject(aSand, 0,1, 0,2)], true, undefined, sandx,sandz );
 				createObjectGroup(group, 0);
 			}
 		} else if (getHeight(sandx,sandz) > -2.5 && getHeight(sandx,sandz) < -1.0)
 		{
 			if (randBool(0.4))
 			{
 				group = new SimpleGroup( [new SimpleObject(aWaterFlower, 1,4, 1,2)], true, undefined, sandx,sandz );
 				createObjectGroup(group, 0);
 			}
 			else if (randBool(0.7) && getHeight(sandx,sandz) < -1.9)
 			{
 				group = new SimpleGroup( [new SimpleObject(aReedsA, 5,12, 0,2),new SimpleObject(aReedsB, 5,12, 0,2)], true, undefined, sandx,sandz );
 				createObjectGroup(group, 0);
 			}
 
 			if (getTileClass(clPassage).countInRadius(sandx,sandz,2,true) > 0) {
 				if (randBool(0.4))
 				{
 					group = new SimpleGroup( [new SimpleObject(aWaterFlower, 1,4, 1,2)], true, undefined, sandx,sandz );
 					createObjectGroup(group, 0);
 				}
 				else if (randBool(0.7) && getHeight(sandx,sandz) < -1.9)
 				{
 					group = new SimpleGroup( [new SimpleObject(aReedsA, 5,12, 0,2),new SimpleObject(aReedsB, 5,12, 0,2)], true, undefined, sandx,sandz );
 					createObjectGroup(group, 0);
 				}
 			}
 		}
 	}
 
 setSkySet("sunny");
 setSunColor(0.914,0.827,0.639);
 setSunRotation(PI/3);
 setSunElevation(0.5);
 setWaterColor(0, 0.227, 0.843);
 setWaterTint(0, 0.545, 0.859);
 setWaterWaviness(1.0);
 setWaterType("clap");
 setWaterMurkiness(0.5);
 setTerrainAmbientColor(0.45, 0.5, 0.6);
 setUnitsAmbientColor(0.501961, 0.501961, 0.501961);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/persian_highlands.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/persian_highlands.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/persian_highlands.js	(revision 20149)
@@ -1,403 +1,390 @@
 RMS.LoadLibrary("rmgen");
 
 const tCity = "desert_city_tile_pers_dirt";
 
 if (randBool()) // summer
 {
 	var tDirtMain = ["desert_dirt_persia_1", "desert_dirt_persia_2", "grass_field_dry"];
 	var tLakebed1 = ["desert_lakebed_dry_b", "desert_lakebed_dry"];
 	var tLakebed2 = ["desert_lakebed_dry_b", "desert_lakebed_dry", "desert_shore_stones", "desert_shore_stones"];
 	var tPebbles = "desert_pebbles_rough";
 	var tCliff = ["desert_cliff_persia_1", "desert_cliff_persia_crumbling"];
 	var tForestFloor = "medit_grass_field_dry";
 	var tRocky = "desert_dirt_persia_rocky";
 	var tRocks = "desert_dirt_persia_rocks";
 	var tGrass = "grass_field_dry";
 	var tHill = "desert_cliff_persia_base";
 }
 else //spring
 {
 	var tDirtMain = ["desert_grass_a", "desert_grass_a", "desert_grass_a", "desert_plants_a"];
 	var tLakebed1 = ["desert_lakebed_dry_b", "desert_lakebed_dry"];
 	var tLakebed2 = "desert_grass_a_sand";
 	var tPebbles = "desert_pebbles_rough";
 	var tCliff = ["desert_cliff_persia_1", "desert_cliff_persia_crumbling"];
 	var tForestFloor = "desert_plants_b_persia";
 	var tRocky = "desert_plants_b_persia";
 	var tRocks = "desert_plants_a";
 	var tGrass = "desert_dirt_persia_rocky";
 	var tHill = "desert_cliff_persia_base";
 
 	setTerrainAmbientColor(0.329412, 0.419608, 0.501961);
 }
 
 const oGrapesBush = "gaia/flora_bush_grapes";
 const oCamel = "gaia/fauna_camel";
 const oFish = "gaia/fauna_fish";
 const oSheep = "gaia/fauna_sheep";
 const oGoat = "gaia/fauna_goat";
 const oLion = "gaia/fauna_lioness";
 const oStoneLarge = "gaia/geology_stonemine_desert_badlands_quarry";
 const oStoneSmall = "gaia/geology_stone_desert_small";
 const oMetalLarge = "gaia/geology_metal_desert_slabs";
 const oTamarix = "gaia/flora_tree_tamarix";
 const oOak = "gaia/flora_tree_oak";
 
 const aBush1 = "actor|props/flora/bush_desert_a.xml";
 const aBush2 = "actor|props/flora/bush_desert_dry_a.xml";
 const aBush3 = "actor|props/flora/bush_dry_a.xml";
 const aBush4 = "actor|props/flora/plant_desert_a.xml";
 const aBushes = [aBush1, aBush2, aBush3, aBush4];
 const aDecorativeRock = "actor|geology/stone_desert_med.xml";
 
 // terrain + entity (for painting)
 const pForestO = [tForestFloor + TERRAIN_SEPARATOR + oOak, tForestFloor + TERRAIN_SEPARATOR + oOak, tForestFloor, tDirtMain, tDirtMain];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 const mapArea = mapSize*mapSize;
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clPatch = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clCP = createTileClass();
 
 initTerrain(tDirtMain);
 
-var playerIDs = sortAllPlayers();
-
-// 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 [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	// scale radius of player area by map size
 	var radius = scaleByMapSize(15,25);
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 
 	// calculate size based on the radius
 	var size = PI * radius * radius;
 
 	// create the player area
 	var placer = new ClumpPlacer(size, 0.9, 0.5, 10, ix, iz);
 	createArea(placer, paintClass(clPlayer), null);
 
 	// create the city patch
 	var cityRadius = 10;
 	placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tCity, tCity], [3]);
 	createArea(placer, painter, null);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oGrapesBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = 11;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0), new RandomObject(aBushes, 2,4, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2), new RandomObject(aBushes, 2,4, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var num = 3;
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(11, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oOak, num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 }
 
 RMS.SetProgress(10);
 
 log("Creating rock patches...");
 placer = new ChainPlacer(1, floor(scaleByMapSize(3, 6)), floor(scaleByMapSize(20, 45)), 0);
 painter = new TerrainPainter(tRocky);
 createAreas(placer, [painter, paintClass(clPatch)],
 	avoidClasses(clPatch, 2, clPlayer, 0),
 	scaleByMapSize(5, 20)
 );
 
 RMS.SetProgress(15);
 
 var placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), floor(scaleByMapSize(15, 40)), 0);
 var painter = new TerrainPainter([tRocky, tRocks]);
 createAreas(placer, [painter, paintClass(clPatch)],
 	avoidClasses(clPatch, 2, clPlayer, 4),
 	scaleByMapSize(15, 50)
 );
 
 RMS.SetProgress(20);
 
 log("Creating dirt patches...");
 placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), floor(scaleByMapSize(15, 40)), 0);
 painter = new TerrainPainter([tGrass]);
 createAreas(placer, [painter, paintClass(clPatch)],
 	avoidClasses(clPatch, 2, clPlayer, 4),
 	scaleByMapSize(15, 50)
 );
 
 RMS.SetProgress(25);
 
 log("Creating centeral plateau...");
 var halfSize = mapSize / 2;
 var oRadius = scaleByMapSize(18, 68);
 placer = new ChainPlacer(2, floor(scaleByMapSize(5, 13)), floor(scaleByMapSize(35, 200)), 1, halfSize, halfSize, 0, [floor(oRadius)]);
 painter = new LayeredPainter([tLakebed2, tLakebed1], [6]);
 var elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, -10, 8);
 createArea(placer, [painter, elevationPainter, paintClass(clCP)], avoidClasses(clPlayer, 18));
 
 RMS.SetProgress(30);
 
 log("Creating hills...");
 var numHills = scaleByMapSize(20, 80);
 for (var i = 0; i < numHills; ++i)
 {
 
 	createMountain(
 		floor(scaleByMapSize(40, 60)),
 		floor(scaleByMapSize(3, 4)),
 		floor(scaleByMapSize(6, 12)),
 		floor(scaleByMapSize(4, 10)),
 		avoidClasses(clPlayer, 7, clCP, 5, clHill, floor(scaleByMapSize(18, 25))),
 		randIntExclusive(0, mapSize),
 		randIntExclusive(0, mapSize),
 		tCliff,
 		clHill,
 		14
 	);
 }
 
 RMS.SetProgress(35);
 
 // calculate desired number of trees for map (based on size)
 const MIN_TREES = 500;
 const MAX_TREES = 2500;
 const P_FOREST = 0.7;
 
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 var numForest = totalTrees * P_FOREST;
 var numStragglers = totalTrees * (1.0 - P_FOREST);
 
 log("Creating forests...");
 var types = [
 	[[tDirtMain, tForestFloor, pForestO], [tForestFloor, pForestO]],
 	[[tDirtMain, tForestFloor, pForestO], [tForestFloor, pForestO]]
 ];	// some variation
 var size = numForest / (scaleByMapSize(3,6) * numPlayers);
 var num = floor(size / types.length);
 for (var i = 0; i < types.length; ++i)
 {
 	placer = new ChainPlacer(floor(scaleByMapSize(1, 2)), floor(scaleByMapSize(2, 5)), floor(size / floor(scaleByMapSize(8, 3))), 1);
 	painter = new LayeredPainter(
 		types[i],		// terrains
 		[2]											// widths
 		);
 	createAreas(
 		placer,
 		[painter, paintClass(clForest)],
 		avoidClasses(clPlayer, 6, clForest, 10, clHill, 1, clCP, 1),
 		num
 	);
 }
 RMS.SetProgress(50);
 
 log("Creating stone mines...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4), new RandomObject(aBushes, 2,4, 0,2)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 10, clRock, 10, clHill, 1, clCP, 1)],
 	scaleByMapSize(2,8), 100
 );
 
 log("Creating small stone quarries...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3), new RandomObject(aBushes, 2,4, 0,2)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 10, clRock, 10, clHill, 1, clCP, 1)],
 	scaleByMapSize(2,8), 100
 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4), new RandomObject(aBushes, 2,4, 0,2)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 10, clMetal, 10, clRock, 5, clHill, 1, clCP, 1)],
 	scaleByMapSize(2,8), 100
 );
 
 log("Creating centeral stone mines...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4), new RandomObject(aBushes, 2,4, 0,2)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	stayClasses(clCP, 6),
 	5*scaleByMapSize(5,30), 50
 );
 
 log("Creating small stone quarries...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3), new RandomObject(aBushes, 2,4, 0,2)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	stayClasses(clCP, 6),
 	5*scaleByMapSize(5,30), 50
 );
 
 log("Creating centeral metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4), new RandomObject(aBushes, 2,4, 0,2)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	stayClasses(clCP, 6),
 	5*scaleByMapSize(5,30), 50
 );
 
 RMS.SetProgress(60);
 
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aDecorativeRock, 1,3, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clForest, 0, clPlayer, 0, clHill, 0),
 	scaleByMapSize(16, 262), 50
 );
 
 RMS.SetProgress(65);
 
 log("Creating bushes...");
 group = new SimpleGroup(
 	[new SimpleObject(aBush2, 1,2, 0,1), new SimpleObject(aBush1, 1,3, 0,2)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clForest, 0, clPlayer, 0, clHill, 0),
 	scaleByMapSize(8, 131), 50
 );
 
 RMS.SetProgress(70);
 
 log("Creating goat...");
 group = new SimpleGroup(
 	[new SimpleObject(oGoat, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 1, clHill, 1, clFood, 20, clCP, 2),
 	3 * numPlayers, 50
 );
 
 log("Creating sheep...");
 group = new SimpleGroup(
 	[new SimpleObject(oSheep, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 1, clHill, 1, clFood, 20, clCP, 2),
 	3 * numPlayers, 50
 );
 
 log("Creating grape bush...");
 group = new SimpleGroup(
 	[new SimpleObject(oGrapesBush, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 20, clHill, 1, clFood, 10, clCP, 2),
 	randIntInclusive(1, 4) * numPlayers + 2, 50
 );
 
 log("Creating camels...");
 group = new SimpleGroup(
 	[new SimpleObject(oCamel, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	stayClasses(clCP, 2),
 	3 * numPlayers, 50
 );
 
 RMS.SetProgress(90);
 
 log("Creating straggler trees...");
 var types = [oOak];	// some variation
 var num = floor(numStragglers / types.length);
 for (var i = 0; i < types.length; ++i)
 {
 	group = new SimpleGroup(
 		[new SimpleObject(types[i], 1,1, 0,3)],
 		true, clForest
 	);
 	createObjectGroupsDeprecated(group, 0,
 		avoidClasses(clForest, 1, clHill, 1, clPlayer, 1, clMetal, 6, clRock, 6, clCP, 2),
 		num
 	);
 }
 
 setSunColor(1.0, 0.796, 0.374);
 setSunElevation(PI / 6);
 setSunRotation(-1.86532);
 
 setFogFactor(0.2);
 setFogThickness(0.0);
 setFogColor(0.852, 0.746, 0.493);
 
 setPPEffect("hdr");
 setPPContrast(0.75);
 setPPSaturation(0.45);
 setPPBloom(0.3);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/polar_sea.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/polar_sea.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/polar_sea.js	(revision 20149)
@@ -1,349 +1,337 @@
 RMS.LoadLibrary("rmgen");
 
 var tPrimary = ["polar_snow_a"];
 var tCliff = ["polar_cliff_a", "polar_cliff_b", "polar_cliff_snow"];
 var tSecondary = "polar_snow_glacial";
 var tHalfSnow = ["ice_01", "ice_dirt"];
 var tSnowLimited = ["polar_snow_b", "polar_ice"];
 var tDirt = "ice_dirt";
 var tRoad = "polar_ice_b";
 var tRoadWild = "polar_ice_cracked";
 var tShore = "polar_ice_snow";
 var tWater = "polar_ice_c";
 
 var oArcticFox = "gaia/fauna_fox_arctic";
 var oWolf = "trigger/fauna_wolf_snow_attack";
 var oMuskox = "gaia/fauna_muskox";
 var oWalrus = "gaia/fauna_walrus";
 var oWhaleFin = "gaia/fauna_whale_fin";
 var oWhaleHumpback = "gaia/fauna_whale_humpback";
 var oFish = "gaia/fauna_fish";
 var oStoneLarge = "gaia/geology_stonemine_medit_quarry";
 var oStoneSmall = "gaia/geology_stone_alpine_a";
 var oMetalLarge = "gaia/geology_metal_desert_badlands_slabs";
 var oWood = "gaia/special_treasure_wood";
 
 var aRockLarge = "actor|geology/stone_granite_med.xml";
 var aRockMedium = "actor|geology/stone_granite_med.xml";
 var aIceberg = "actor|props/special/eyecandy/iceberg.xml";
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 
 var clPlayer = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clHill = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clWolf = createTileClass();
 
 // Expected by rmgen1
 var clForest = createTileClass();
 
 initTerrain(tPrimary);
 
-var playerIDs = sortAllPlayers();
-
-var playerX = new Array(numPlayers);
-var playerZ = new Array(numPlayers);
-var playerAngle = new Array(numPlayers);
-
-var startAngle = randFloat(0, TWO_PI);
-for (let i = 0; i < numPlayers; ++i)
-{
-	playerAngle[i] = startAngle + i * TWO_PI / numPlayers;
-	playerX[i] = 0.5 + 0.35 * Math.cos(playerAngle[i]);
-	playerZ[i] = 0.5 + 0.35 * Math.sin(playerAngle[i]);
-}
+var [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 RMS.SetProgress(20);
 
 for (let i = 0; i < numPlayers; ++i)
 {
 	let id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	let fx = fractionToTiles(playerX[i]);
 	let fz = fractionToTiles(playerZ[i]);
 	let ix = Math.round(fx);
 	let iz = Math.round(fz);
 
 	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
 	let cityRadius = scaleByMapSize(15,25)/3;
 	let placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	let painter = new LayeredPainter([tRoadWild, tRoad], [1]);
 	createArea(placer, painter, null);
 
 	placeCivDefaultEntities(fx, fz, id, { 'iberWall': 'towers' });
 
 	placeDefaultChicken(fx, fz, clBaseResource, undefined, oMuskox);
 
 	// Create metal mine
 	let mAngle = randFloat(0, TWO_PI);
 	let mDist = 12;
 	let mX = Math.round(fx + mDist * Math.cos(mAngle));
 	let mZ = Math.round(fz + mDist * Math.sin(mAngle));
 	let group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1, 1, 0, 0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// Create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = Math.round(fx + mDist * Math.cos(mAngle));
 	mZ = Math.round(fz + mDist * Math.sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1, 1, 0, 2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// Create wood treasure
 	mAngle += PI/4;
 	let bbX = Math.round(fx + mDist * Math.cos(mAngle));
 	let bbZ = Math.round(fz + mDist * Math.sin(mAngle));
 	createObjectGroup(
 		new SimpleGroup(
 			[new SimpleObject(oWood, 14,14, 0,3)],
 			true, clBaseResource, bbX, bbZ,
 			avoidClasses(clBaseResource, 4)
 		), 0);
 
 	// Create market
 	mAngle += PI/4;
 	placeObject(
 		Math.round(fx + mDist * Math.cos(mAngle)),
 		Math.round(fz + mDist * Math.sin(mAngle)),
 		"structures/" + getCivCode(id-1) + "_market",
 		id,
 		BUILDING_ORIENTATION);
 }
 RMS.SetProgress(30);
 
 log("Creating central lake...");
 var placer = new ChainPlacer(
 	2,
 	Math.floor(scaleByMapSize(5, 16)),
 	Math.floor(scaleByMapSize(35, 200)),
 	1,
 	Math.round(fractionToTiles(0.5)),
 	Math.round(fractionToTiles(0.5)),
 	0,
 	[Math.floor(mapSize * 0.17)]);
 
 var terrainPainter = new LayeredPainter(
 	[tShore, tWater, tWater, tWater],		// terrains
 	[1, 4, 2]		// widths
 );
 var elevationPainter = new SmoothElevationPainter(
 	ELEVATION_SET,			// type
 	-4,				// elevation
 	4				// blend radius
 );
 createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 20));
 
 paintTerrainBasedOnHeight(3, Math.floor(scaleByMapSize(20, 40)), 0, tCliff);
 paintTerrainBasedOnHeight(Math.floor(scaleByMapSize(20, 40)), 100, 3, tSnowLimited);
 RMS.SetProgress(40);
 
 log("Creating small lakes...");
 var lakeAreas = [];
 var playerConstraint = new AvoidTileClassConstraint(clPlayer, 20);
 var waterConstraint = new AvoidTileClassConstraint(clWater, 8);
 for (let x = 0; x < mapSize; ++x)
 	for (let z = 0; z < mapSize; ++z)
 		if (playerConstraint.allows(x, z) && waterConstraint.allows(x, z))
 			lakeAreas.push([x, z]);
 
 var numLakes = scaleByMapSize(10, 16);
 for (let i = 0; i < numLakes ; ++i)
 {
 	let chosenPoint = pickRandom(lakeAreas);
 	if (!chosenPoint)
 		break;
 
 	placer = new ChainPlacer(
 		1,
 		Math.floor(scaleByMapSize(2, 4)),
 		Math.floor(scaleByMapSize(20, 140)),
 		0.7,
 		chosenPoint[0],
 		chosenPoint[1]);
 
 	let terrainPainter = new LayeredPainter(
 		[tShore, tWater, tWater],		// terrains
 		[1, 3]								// widths
 	);
 	let elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -5, 5);
 	createAreas(
 		placer,
 		[terrainPainter, elevationPainter, paintClass(clWater)],
 		avoidClasses(clPlayer, 20),
 		1, 1
 	);
 }
 RMS.SetProgress(50);
 
 createBumps(avoidClasses(clWater, 2, clPlayer, 20));
 RMS.SetProgress(60);
 
 log("Creating hills...");
 createHills(
 	[tPrimary, tPrimary, tSecondary],
 	avoidClasses(clPlayer, 20, clHill, 35),
 	clHill, scaleByMapSize(20, 240));
 RMS.SetProgress(65);
 
 log("Creating dirt patches...");
 createLayeredPatches(
 	[scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
 	[[tDirt,tHalfSnow], [tHalfSnow,tSnowLimited]],
 	[2],
 	avoidClasses(clWater, 3, clDirt, 5, clPlayer, 12)
 );
 
 log("Creating glacier patches...");
 createPatches(
 	[scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
 	tSecondary,
 	avoidClasses(clWater, 3, clDirt, 5, clPlayer, 12)
 );
 RMS.SetProgress(70);
 
 log("Creating stone mines...");
 	createMines(
 	[
 		[new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)],
 		[new SimpleObject(oStoneSmall, 2,5, 1,3)]
 	],
 	avoidClasses(clWater, 3, clPlayer, 20, clRock, 18, clHill, 2)
 );
 
 log("Creating metal mines...");
 createMines(
 	[
 		[new SimpleObject(oMetalLarge, 1,1, 0,4)]
 	],
 	avoidClasses(clWater, 3, clPlayer, 20, clMetal, 18, clRock, 5, clHill, 2),
 	clMetal
 );
 RMS.SetProgress(75);
 
 createDecoration(
 	[
 		[new SimpleObject(aRockMedium, 1,3, 0,1)],
 		[
 			new SimpleObject(aRockLarge, 1,2, 0,1),
 			new SimpleObject(aRockMedium, 1,3, 0,2)
 		]
 	],
 	[
 		scaleByMapSize(16, 262),
 		scaleByMapSize(8, 131),
 	],
 	avoidClasses(clWater, 0, clPlayer, 0)
 );
 
 createDecoration(
 	[
 		[new SimpleObject(aIceberg, 1, 1, 1, 1)]
 	],
 	[
 		scaleByMapSize(8, 131)
 	],
 	[stayClasses(clWater, 4), avoidClasses(clHill, 2)]
 );
 RMS.SetProgress(80);
 
 createFood(
 	[
 		[new SimpleObject(oArcticFox, 1,2, 0,3)],
 		[new SimpleObject(oWolf, 4,6, 0,4)],
 		[new SimpleObject(oWalrus, 2,3, 0,2)],
 		[new SimpleObject(oMuskox, 2,3, 0,2)]
 	],
 	[
 		3 * numPlayers,
 		5 * numPlayers,
 		5 * numPlayers,
 		12 * numPlayers
 	],
 	avoidClasses(clPlayer, 35, clFood, 16, clWater, 2, clMetal, 4, clRock, 4, clHill, 2)
 );
 
 createFood(
 	[
 		[new SimpleObject(oWhaleFin, 1,2, 0,2)],
 		[new SimpleObject(oWhaleHumpback, 1,2, 0,2)]
 	],
 	[
 		scaleByMapSize(1, 6) * 3,
 		scaleByMapSize(1, 6) * 3,
 	],
 	[avoidClasses(clFood, 20, clHill, 5), stayClasses(clWater, 6)]
 );
 
 createFood(
 	[
 		[new SimpleObject(oFish, 2,3, 0,2)]
 	],
 	[
 		100
 	],
 	[avoidClasses(clFood, 12, clHill, 5), stayClasses(clWater, 6)]
 );
 RMS.SetProgress(85);
 
 // Create trigger points where wolves spawn
 createObjectGroupsDeprecated(
 	new SimpleGroup([new SimpleObject("special/trigger_point_A", 1, 1, 0, 0)], true, clWolf),
 	0,
 	avoidClasses(clWater, 2, clMetal, 4, clRock, 4, clPlayer, 15, clHill, 2, clWolf, 20),
 	1000,
 	100
 );
 RMS.SetProgress(95);
 
 if (randBool(1/3))
 {
 	setSkySet("sunset 1");
 	setSunColor(0.8, 0.7, 0.6);
 	setTerrainAmbientColor(0.7, 0.6, 0.7);
 	setUnitsAmbientColor(0.6, 0.5, 0.6);
 	setSunElevation(randFloat(PI/24, PI/7));
 }
 else
 {
 	setSkySet(pickRandom(["cumulus", "rain", "mountainous", "overcast", "rain", "stratus"]));
 	setSunElevation(randFloat(PI/9, PI/7));
 }
 
 setSunRotation(randFloat(0, TWO_PI));
 
 setWaterColor(0.3, 0.3, 0.4);
 setWaterTint(0.75, 0.75, 0.75);
 setWaterMurkiness(0.92);
 setWaterWaviness(0.5);
 setWaterType("clap");
 
 setFogThickness(0.76);
 setFogFactor(0.7);
 
 setPPEffect("hdr");
 setPPContrast(0.6);
 setPPSaturation(0.45);
 setPPBloom(0.4);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/rivers.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/rivers.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/rivers.js	(revision 20149)
@@ -1,467 +1,454 @@
 RMS.LoadLibrary("rmgen");
 RMS.LoadLibrary("rmbiome");
 
 setSelectedBiome();
 
 const tMainTerrain = g_Terrains.mainTerrain;
 const tForestFloor1 = g_Terrains.forestFloor1;
 const tForestFloor2 = g_Terrains.forestFloor2;
 const tCliff = g_Terrains.cliff;
 const tTier1Terrain = g_Terrains.tier1Terrain;
 const tTier2Terrain = g_Terrains.tier2Terrain;
 const tTier3Terrain = g_Terrains.tier3Terrain;
 const tHill = g_Terrains.hill;
 const tDirt = g_Terrains.dirt;
 const tRoad = g_Terrains.road;
 const tRoadWild = g_Terrains.roadWild;
 const tTier4Terrain = g_Terrains.tier4Terrain;
 const tShoreBlend = g_Terrains.shoreBlend;
 var tShore = g_Terrains.shore;
 var tWater = g_Terrains.water;
 if (currentBiome() == "tropic")
 {
 	tShore = "tropic_dirt_b_plants";
 	tWater = "tropic_dirt_b";
 }
 const oTree1 = g_Gaia.tree1;
 const oTree2 = g_Gaia.tree2;
 const oTree3 = g_Gaia.tree3;
 const oTree4 = g_Gaia.tree4;
 const oTree5 = g_Gaia.tree5;
 const oFruitBush = g_Gaia.fruitBush;
 const oMainHuntableAnimal = g_Gaia.mainHuntableAnimal;
 const oFish = g_Gaia.fish;
 const oSecondaryHuntableAnimal = g_Gaia.secondaryHuntableAnimal;
 const oStoneLarge = g_Gaia.stoneLarge;
 const oStoneSmall = g_Gaia.stoneSmall;
 const oMetalLarge = g_Gaia.metalLarge;
 
 const aGrass = g_Decoratives.grass;
 const aGrassShort = g_Decoratives.grassShort;
 const aReeds = g_Decoratives.reeds;
 const aLillies = g_Decoratives.lillies;
 const aRockLarge = g_Decoratives.rockLarge;
 const aRockMedium = g_Decoratives.rockMedium;
 const aBushMedium = g_Decoratives.bushMedium;
 const aBushSmall = g_Decoratives.bushSmall;
 
 const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
 const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 const mapArea = mapSize*mapSize;
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clSettlement = createTileClass();
 var clShallow = createTileClass();
 
 initTerrain(tMainTerrain);
 
 var fx = fractionToTiles(0.5);
 var fz = fractionToTiles(0.5);
 ix = round(fx);
 iz = round(fz);
 
 var lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 6))));
 
 var placer = new ClumpPlacer(mapArea * 0.01 * lSize, 0.7, 0.1, 10, ix, iz);
 var terrainPainter = new LayeredPainter(
 	[tShore, tWater, tWater, tWater],		// terrains
 	[1, 4, 2]		// widths
 );
 var elevationPainter = new SmoothElevationPainter(
 	ELEVATION_SET,			// type
 	-3,				// elevation
 	4				// blend radius
 );
 createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], null);
 
-var playerIDs = sortAllPlayers();
-
-// 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 [playerIDs, playerX, playerZ, playerAngle, startAngle] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	fx = fractionToTiles(playerX[i]);
 	fz = fractionToTiles(playerZ[i]);
 	ix = round(fx);
 	iz = round(fz);
 	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(oFruitBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 		mAngle = randFloat(0, TWO_PI);
 
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var num = 2;
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(11, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oTree1, num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 
 RMS.SetProgress(20);
 
 //init rivers
 var PX = new Array(numPlayers+1);
 var PZ = new Array(numPlayers+1);
 //isRiver actually tells us if two points must be joined by river
 var isRiver = new Array(numPlayers+1);
 for (var q=0; q <numPlayers+1; q++)
 	isRiver[q]=new Array(numPlayers+1);
 
 //At first nothing is joined
 for (let m = 0; m < numPlayers + 1; ++m)
 	for (let n = 0; n < numPlayers + 1; ++n)
 		isRiver[m][n] = 0;
 
 //creating the first point in the center. all others are
 //connected to this one so all of our rivers join together
 //in the middle of the map
 var fx = fractionToTiles(0.5);
 var fz = fractionToTiles(0.5);
 var ix = round(fx);
 var iz = round(fz);
 PX[numPlayers]= fx;
 PZ[numPlayers]= fz;
 
 var riverAngle = new Array(numPlayers);
 for (var c = 0 ; c < numPlayers ; c++)
 {
 	//creating other points of the river and making them
 	// join the point in the center of the map
 	riverAngle[c] = startAngle + (((2 * c + 1) / (numPlayers * 2)) * TWO_PI );
 	PX[c] = round(fractionToTiles(0.5 + 0.5 * cos(riverAngle[c])));
 	PZ[c] = round(fractionToTiles(0.5 + 0.5 * sin(riverAngle[c])));
 	//log (playerIDs[c], ",,," ,playerIDs[0]);
 	//isRiver[c][numPlayers]=1;
 	if ((c == numPlayers-1)&&(!areAllies(playerIDs[c]-1, playerIDs[0]-1)))
 		isRiver[c][numPlayers]=1;
 	else if ((c < numPlayers-1)&&(!areAllies(playerIDs[c]-1, playerIDs[c+1]-1)))
 		isRiver[c][numPlayers]=1;
 }
 
 //theta is the start value for rndRiver function. seed implies
 //the randomness. we must have one of these for each river we create.
 //shallowpoint and shallow length define the place and size of the shallow part
 var theta = new Array(numPlayers);
 var seed = new Array(numPlayers);
 var shallowpoint = new Array(numPlayers);
 var shallowlength = new Array(numPlayers);
 for (let q = 0; q < numPlayers + 1; ++q)
 {
 	theta[q]=randFloat(0, 1);
 	seed[q]=randFloat(2,3);
 	shallowpoint[q]=randFloat(0.2,0.7);
 	shallowlength[q]=randFloat(0.12,0.21);
 }
 
 log ("Creating rivers...");
 //checking all the tiles
 for (var ix = 0; ix < mapSize; ix++)
 	for (var iz = 0; iz < mapSize; iz++)
 		for (var m = 0; m < numPlayers+1; m++)
 			for (var n = 0; n < numPlayers+1; n++)
 			{
 				//checking if there is a river between those points
 				if(isRiver[m][n] == 1)
 				{
 					//very important calculations. don't change anything. results
 					//"dis" which is the distance to the riverline and "y" and "xm" which are
 					//the coordinations for the point it's image is in.
 					var a = PZ[m]-PZ[n];
 					var b = PX[n]-PX[m];
 					var c = (PZ[m]*(PX[m]-PX[n]))-(PX[m]*(PZ[m]-PZ[n]));
 					var dis = abs(a*ix + b*iz + c)/sqrt(a*a + b*b);
 					if (abs(a*ix + b*iz + c) != 0)
 					{
 						var alamat = (a*ix + b*iz + c)/abs(a*ix + b*iz + c);
 					}
 					else
 					{
 						var alamat = 1;
 					}
 					var k = (a*ix + b*iz + c)/(a*a + b*b);
 					var y = iz-(b*k);
 					var xm = ix-(a*k);
 					//this calculates which "part" of the river are we in now.
 					//used for the function rndRiver.
 					var sit = sqrt((PZ[n]-y)*(PZ[n]-y)+(PX[n]-xm)*(PX[n]-xm))/sqrt((PZ[n]-PZ[m])*(PZ[n]-PZ[m])+(PX[n]-PX[m])*(PX[n]-PX[m]));
 					var sbms = scaleByMapSize(5,15) + alamat * ( scaleByMapSize(20, 60) * rndRiver( theta[m] + sit * 0.5 * (mapSize/64) , seed[m]) );
 					if((dis < sbms)&&(y <= Math.max(PZ[m],PZ[n]))&&(y >= Math.min(PZ[m],PZ[n])))
 					{
 						//create the deep part of the river
 						if (dis <= sbms-5){
 							if ((sit > shallowpoint[m])&&(sit < shallowpoint[m]+shallowlength[m]))
 							{
 								//create the shallow part
 								var h = -1;
 								addToClass(ix, iz, clShallow);
 							}
 							else
 							{
 								var h = -3;
 							}
 							var t = tWater;
 							addToClass(ix, iz, clWater);
 						}
 						//creating the rough edges
 						else if (dis <= sbms)
 						{
 							if ((sit > shallowpoint[m])&&(sit < shallowpoint[m]+shallowlength[m]))
 							{
 								if (2-(sbms-dis)<-1)
 								{
 									//checking if there is shallow water here
 									var h = -1;
 									addToClass(ix, iz, clShallow);
 								}
 								else
 								{
 									var h = 2-(sbms-dis);
 								}
 							}
 							else
 							{
 								var h = 2-(sbms-dis);
 							}
 							//we must create shore lines for more beautiful terrain
 							if (sbms-dis<=2)
 							{
 								var t = tShore;
 							}
 							else
 							{
 								var t = tWater;
 							}
 							addToClass(ix, iz, clWater);
 						}
 						//we don't want to cause problems when river joins sea
 						if (getHeight(ix, iz)>h)
 						{
 							placeTerrain(ix, iz, t);
 							setHeight(ix, iz, h);
 						}
 					}
 				}
 			}
 
 RMS.SetProgress(40);
 
 createBumps(avoidClasses(clWater, 2, clPlayer, 20));
 
 if (randBool())
 	createHills([tMainTerrain, tCliff, tHill], avoidClasses(clPlayer, 20, clHill, 15, clWater, 2), clHill, scaleByMapSize(3, 15));
 else
 	createMountains(tCliff, avoidClasses(clPlayer, 20, clHill, 15, clWater, 2), clHill, scaleByMapSize(3, 15));
 
 createForests(
  [tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
  avoidClasses(clPlayer, 20, clForest, 17, clHill, 0, clWater, 2),
  clForest,
  1,
  ...rBiomeTreeCount(1));
 
 RMS.SetProgress(50);
 
 log("Creating dirt patches...");
 createLayeredPatches(
  [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
  [[tMainTerrain,tTier1Terrain],[tTier1Terrain,tTier2Terrain], [tTier2Terrain,tTier3Terrain]],
  [1,1],
  avoidClasses(clWater, 3, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12)
 );
 
 log("Creating grass patches...");
 createPatches(
  [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
  tTier4Terrain,
  avoidClasses(clWater, 3, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12)
 );
 
 RMS.SetProgress(55);
 
 log("Creating stone mines...");
 createMines(
  [
   [new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)],
   [new SimpleObject(oStoneSmall, 2,5, 1,3)]
  ],
  avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clRock, 10, clHill, 1)
 );
 
 log("Creating metal mines...");
 createMines(
  [
   [new SimpleObject(oMetalLarge, 1,1, 0,4)]
  ],
  avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 1),
  clMetal
 );
 
 RMS.SetProgress(65);
 
 var planetm = 1;
 
 if (currentBiome() == "tropic")
 	planetm = 8;
 
 createDecoration
 (
  [[new SimpleObject(aRockMedium, 1,3, 0,1)],
   [new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
   [new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)],
   [new SimpleObject(aGrass, 2,4, 0,1.8, -PI/8,PI/8), new SimpleObject(aGrassShort, 3,6, 1.2,2.5, -PI/8,PI/8)],
   [new SimpleObject(aBushMedium, 1,2, 0,2), new SimpleObject(aBushSmall, 2,4, 0,2)]
  ],
  [
   scaleByMapSize(16, 262),
   scaleByMapSize(8, 131),
   planetm * scaleByMapSize(13, 200),
   planetm * scaleByMapSize(13, 200),
   planetm * scaleByMapSize(13, 200)
  ],
  avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0)
 );
 
 // create water decoration in the shallow parts
 createDecoration
 (
  [[new SimpleObject(aReeds, 1,3, 0,1)],
   [new SimpleObject(aLillies, 1,2, 0,1)]
  ],
  [
   scaleByMapSize(800, 12800),
   scaleByMapSize(800, 12800)
  ],
  stayClasses(clShallow, 0)
 );
 
 RMS.SetProgress(70);
 
 createFood
 (
  [
   [new SimpleObject(oMainHuntableAnimal, 5,7, 0,4)],
   [new SimpleObject(oSecondaryHuntableAnimal, 2,3, 0,2)]
  ],
  [
   3 * numPlayers,
   3 * numPlayers
  ],
  avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 20)
 );
 
 createFood
 (
  [
   [new SimpleObject(oFruitBush, 5,7, 0,4)]
  ],
  [
   3 * numPlayers
  ],
  avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 10)
 );
 
 createFood
 (
  [
   [new SimpleObject(oFish, 2,3, 0,2)]
  ],
  [
   25 * numPlayers
  ],
  [avoidClasses(clFood, 20), stayClasses(clWater, 6)]
 );
 
 RMS.SetProgress(85);
 
 var types = [oTree1, oTree2, oTree4, oTree3];	// some variation
 createStragglerTrees(types, avoidClasses(clWater, 5, clForest, 7, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6));
 
 setWaterWaviness(3.0);
 setWaterType("lake");
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/saharan_oases.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/saharan_oases.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/saharan_oases.js	(revision 20149)
@@ -1,315 +1,303 @@
 RMS.LoadLibrary("rmgen");
 
 const tCity = "desert_city_tile";
 const tCityPlaza = "desert_city_tile_plaza";
 const tMain = ["desert_dirt_rough", "desert_dirt_rough_2", "desert_sand_dunes_50", "desert_sand_smooth"];
 const tDunes = "desert_sand_dunes_100";
 const tFineSand = "desert_sand_smooth";
 const tCliff = ["desert_cliff_badlands", "desert_cliff_badlands_2"];
 const tForestFloor = "desert_forestfloor_palms";
 const tDirt1 = "desert_dirt_rough_2";
 const tSandDunes = "desert_sand_dunes_50";
 const tDirt2 = "desert_dirt_rough";
 const tDirtCracks = "desert_dirt_cracks";
 const tShore = "desert_shore_stones";
 const tWaterDeep = "desert_shore_stones_wet";
 const tLush = "desert_grass_a";
 const tSLush = "desert_grass_a_sand";
 const tSDry = "desert_plants_b";
 
 const oGrapeBush = "gaia/flora_bush_grapes";
 const oCamel = "gaia/fauna_camel";
 const oFish = "gaia/fauna_fish";
 const oGazelle = "gaia/fauna_gazelle";
 const oGiraffe = "gaia/fauna_giraffe";
 const oGoat = "gaia/fauna_goat";
 const oWildebeest = "gaia/fauna_wildebeest";
 const oStoneLarge = "gaia/geology_stonemine_desert_badlands_quarry";
 const oStoneSmall = "gaia/geology_stone_desert_small";
 const oMetalLarge = "gaia/geology_metal_desert_slabs";
 const oDatePalm = "gaia/flora_tree_date_palm";
 const oSDatePalm = "gaia/flora_tree_cretan_date_palm_short";
 const oWood = "gaia/special_treasure_wood";
 const oFood = "gaia/special_treasure_food_bin";
 
 const aBush1 = "actor|props/flora/bush_desert_a.xml";
 const aBush2 = "actor|props/flora/bush_desert_dry_a.xml";
 const aBush3 = "actor|props/flora/bush_medit_sm_dry.xml";
 const aBush4 = "actor|props/flora/plant_desert_a.xml";
 const aBushes = [aBush1, aBush2, aBush3, aBush4];
 const aDecorativeRock = "actor|geology/stone_desert_med.xml";
 const aReeds = "actor|props/flora/reeds_pond_lush_a.xml";
 const aLillies = "actor|props/flora/water_lillies.xml";
 
 // terrain + entity (for painting)
 const pForest = [tLush + TERRAIN_SEPARATOR + oDatePalm, tLush + TERRAIN_SEPARATOR + oSDatePalm, tLush];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 const mapArea = mapSize*mapSize;
 
 var clPlayer = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clSettlement = createTileClass();
 var clGrass = createTileClass();
 var clDesert = createTileClass();
 var clPond = createTileClass();
 var clShore = createTileClass();
 var clTreasure = createTileClass();
 
-var playerIDs = sortAllPlayers();
-
-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 [playerIDs, playerX, playerZ, playerAngle] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = floor(fx);
 	var iz = floor(fz);
 	addToClass(ix, iz, clPlayer);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	var placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tCityPlaza, tCity], [1]);
 	createArea(placer, painter, null);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oGrapeBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = radius - 5;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 	var hillSize = PI * radius * radius;
 	// create starting trees
 	var num = floor(hillSize / 100);
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = 12;
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oSDatePalm, num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aBush1, clBaseResource, radius);
 }
 
 RMS.SetProgress(30);
 
 for (var i = 0; i < numPlayers; i++)
 {
 	log("Creating oases...");
 	var oRadius = scaleByMapSize(16, 60);
 	placer = new ClumpPlacer(PI*oRadius*oRadius*0.185, 0.6, 0.15, 0, mapSize*(0.5 + 0.18*cos(playerAngle[i]) + scaleByMapSize(1, 4)*cos(playerAngle[i])/100), mapSize*(0.5 + 0.18*sin(playerAngle[i]) + scaleByMapSize(1, 4)*sin(playerAngle[i])/100));
 	painter = new LayeredPainter([tSLush ,[tLush, pForest], [tLush, pForest], tShore, tShore, tWaterDeep], [2, 2, 1, 3, 1]);
 	var elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, -3, 10);
 	createArea(placer, [painter, elevationPainter, paintClass(clWater)], null);
 }
 
 log("Creating grass patches...");
 var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
 for (var i = 0; i < sizes.length; i++)
 {
 	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
 	painter = new LayeredPainter(
 		[[tDirt1,tSandDunes],[tSandDunes,tDirt2], [tDirt2,tDirt1]], 		// terrains
 		[1,1]															// widths
 	);
 	createAreas(
 		placer,
 		[painter, paintClass(clDirt)],
 		avoidClasses(clForest, 0, clGrass, 5, clPlayer, 0, clWater, 1, clDirt, 5, clShore, 1),
 		scaleByMapSize(15, 45)
 	);
 }
 
 RMS.SetProgress(55);
 
 log("Creating dirt patches...");
 var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
 for (var i = 0; i < sizes.length; i++)
 {
 	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
 	painter = new LayeredPainter(
 		[[tDirt2,tDirtCracks],[tDirt2,tFineSand], [tDirtCracks,tFineSand]], 		// terrains
 		[1,1]															// widths
 	);
 	createAreas(
 		placer,
 		[painter, paintClass(clDirt)],
 		avoidClasses(clForest, 0, clDirt, 5, clPlayer, 0, clWater, 1, clGrass, 5, clShore, 1),
 		scaleByMapSize(15, 45)
 	);
 }
 
 RMS.SetProgress(60);
 
 log("Creating stone mines...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 1, clPlayer, 26, clRock, 10, clWater, 1),
 	2*scaleByMapSize(4,16), 100
 );
 
 log("Creating small stone quarries...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 1, clPlayer, 26, clRock, 10, clWater, 1),
 	2*scaleByMapSize(4,16), 100
 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 1, clPlayer, 26, clMetal, 10, clRock, 5, clWater, 1),
 	2*scaleByMapSize(4,16), 100
 );
 
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aDecorativeRock, 1,3, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clWater, 1, clForest, 0, clPlayer, 0, clPond, 1),
 	scaleByMapSize(16, 262), 50
 );
 
 log("Creating shrubs...");
 group = new SimpleGroup(
 	[new SimpleObject(aBush2, 1,2, 0,1), new SimpleObject(aBush1, 1,3, 0,2), new SimpleObject(aBush4, 1,2, 0,1), new SimpleObject(aBush3, 1,3, 0,2)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clWater, 1, clPlayer, 0, clPond, 1),
 	scaleByMapSize(10, 100), 50
 );
 
 log("Creating small decorative rocks on mines...");
 group = new SimpleGroup(
 	[new SimpleObject(aDecorativeRock, 1,3, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	stayClasses(clRock, 0),
 	5*scaleByMapSize(16, 262), 50
 );
 
 group = new SimpleGroup(
 	[new SimpleObject(aDecorativeRock, 1,3, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	stayClasses(clMetal, 0),
 	5*scaleByMapSize(16, 262), 50
 );
 
 log("Creating gazelles...");
 group = new SimpleGroup([new SimpleObject(oGazelle, 5,7, 0,4)], true, clFood);
 createObjectGroupsDeprecated(group, 0,
 	borderClasses(clWater, 8, 5),
 	6*scaleByMapSize(5,20), 50
 );
 
 log("Creating goats...");
 group = new SimpleGroup([new SimpleObject(oGoat, 2,4, 0,3)], true, clFood);
 createObjectGroupsDeprecated(group, 0,
 	borderClasses(clWater, 8, 5),
 	5*scaleByMapSize(5,20), 50
 );
 
 log("Creating treasures...");
 group = new SimpleGroup([new SimpleObject(oFood, 1,1, 0,2)], true, clTreasure);
 createObjectGroupsDeprecated(group, 0,
 	borderClasses(clWater, 8, 5),
 	3*scaleByMapSize(5,20), 50
 );
 
 group = new SimpleGroup([new SimpleObject(oWood, 1,1, 0,2)], true, clTreasure);
 createObjectGroupsDeprecated(group, 0,
 	borderClasses(clWater, 8, 5),
 	3*scaleByMapSize(5,20), 50
 );
 
 log("Creating camels...");
 group = new SimpleGroup([new SimpleObject(oCamel, 2,4, 0,2)], true, clFood);
 createObjectGroupsDeprecated(group, 0,
 	borderClasses(clWater, 14, 5),
 	5*scaleByMapSize(5,20), 50
 );
 
 setSkySet("sunny");
 setSunColor(0.746, 0.718, 0.539);
 setWaterColor(0, 0.227, 0.843);
 setWaterTint(0, 0.545, 0.859);
 setWaterWaviness(1.0);
 setWaterType("clap");
 setWaterMurkiness(0.5);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/sahel_watering_holes.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/sahel_watering_holes.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/sahel_watering_holes.js	(revision 20149)
@@ -1,500 +1,488 @@
 RMS.LoadLibrary("rmgen");
 
 const tGrass = "savanna_grass_a";
 const tForestFloor = "savanna_forestfloor_a";
 const tCliff = "savanna_cliff_b";
 const tDirtRocksA = "savanna_dirt_rocks_c";
 const tDirtRocksB = "savanna_dirt_rocks_a";
 const tDirtRocksC = "savanna_dirt_rocks_b";
 const tHill = "savanna_cliff_a";
 const tRoad = "savanna_tile_a_red";
 const tRoadWild = "savanna_tile_a_red";
 const tGrassPatch = "savanna_grass_b";
 const tShoreBlend = "savanna_riparian";
 const tShore = "savanna_riparian_bank";
 const tWater = "savanna_riparian_wet";
 
 const oBaobab = "gaia/flora_tree_baobab";
 const oFig = "gaia/flora_tree_fig";
 const oBerryBush = "gaia/flora_bush_berry";
 const oWildebeest = "gaia/fauna_wildebeest";
 const oFish = "gaia/fauna_fish";
 const oGazelle = "gaia/fauna_gazelle";
 const oElephant = "gaia/fauna_elephant_african_bush";
 const oGiraffe = "gaia/fauna_giraffe";
 const oZebra = "gaia/fauna_zebra";
 const oStoneLarge = "gaia/geology_stonemine_desert_quarry";
 const oStoneSmall = "gaia/geology_stone_savanna_small";
 const oMetalLarge = "gaia/geology_metal_savanna_slabs";
 
 const aGrass = "actor|props/flora/grass_savanna.xml";
 const aGrassShort = "actor|props/flora/grass_medit_field.xml";
 const aReeds = "actor|props/flora/reeds_pond_lush_a.xml";
 const aLillies = "actor|props/flora/reeds_pond_lush_b.xml";
 const aRockLarge = "actor|geology/stone_savanna_med.xml";
 const aRockMedium = "actor|geology/stone_savanna_med.xml";
 const aBushMedium = "actor|props/flora/bush_desert_dry_a.xml";
 const aBushSmall = "actor|props/flora/bush_dry_a.xml";
 
 const pForest = [tForestFloor + TERRAIN_SEPARATOR + oBaobab, tForestFloor + TERRAIN_SEPARATOR + oBaobab, tForestFloor];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 const mapArea = mapSize*mapSize;
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clSettlement = createTileClass();
 var clShallows = createTileClass();
 
-var playerIDs = sortAllPlayers();
-
-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 [playerIDs, playerX, playerZ, playerAngle, startAngle] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 	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);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oBerryBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var num = 5;
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(12, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oBaobab, num, num, 0,3)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 
 RMS.SetProgress(20);
 
 log ("Creating rivers...");
 for (var m = 0; m < numPlayers; m++)
 {
 	var tang = startAngle + (m + 0.5) * TWO_PI / numPlayers;
 	placer = new ClumpPlacer(floor(PI*scaleByMapSize(10,50)*scaleByMapSize(10,50)/3), 0.95, 0.6, 10, fractionToTiles(0.5 + 0.15*cos(tang)), fractionToTiles(0.5 + 0.15*sin(tang)));
 	var painter = new LayeredPainter([tShore, tWater, tWater], [1, 3]);
 	var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -4, 4);
 	createArea(placer, [painter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 5));
 	var placer = new PathPlacer(fractionToTiles(0.5 + 0.15*cos(tang)), fractionToTiles(0.5 + 0.15*sin(tang)), fractionToTiles(0.5 + 0.49*cos(tang)), fractionToTiles(0.5 + 0.49*sin(tang)), scaleByMapSize(10,50), 0.2, 3*(scaleByMapSize(1,4)), 0.2, 0.05);
 	var terrainPainter = new LayeredPainter(
 		[tShore, tWater, tWater],		// terrains
 		[1, 3]								// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		-4,				// elevation
 		4				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 5));
 	placer = new ClumpPlacer(floor(PI*scaleByMapSize(10,50)*scaleByMapSize(10,50)/5), 0.95, 0.6, 10, fractionToTiles(0.5 + 0.49*cos(tang)), fractionToTiles(0.5 + 0.49*sin(tang)));
 	var painter = new LayeredPainter([tWater, tWater], [1]);
 	var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -4, 4);
 	createArea(placer, [painter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 5));
 }
 
 for (var i = 0; i < numPlayers; i++)
 {
 	if (i+1 == numPlayers)
 	{
 		passageMaker(
 			round(fractionToTiles(playerX[i])),
 			round(fractionToTiles(playerZ[i])),
 			round(fractionToTiles(playerX[0])),
 			round(fractionToTiles(playerZ[0])),
 			6, -2, -2, 4, clShallows, undefined, -4);
 
 		log("Creating animals in shallows...");
 		var group = new SimpleGroup(
 			[new SimpleObject(oElephant, 2,3, 0,4)],
 			true, clFood, round((fractionToTiles(playerX[i]) + fractionToTiles(playerX[0]))/2), round((fractionToTiles(playerZ[i]) + fractionToTiles(playerZ[0]))/2)
 		);
 		createObjectGroup(group, 0);
 
 		var group = new SimpleGroup(
 			[new SimpleObject(oWildebeest, 5,6, 0,4)],
 			true, clFood, round((fractionToTiles(playerX[i]) + fractionToTiles(playerX[0]))/2), round((fractionToTiles(playerZ[i]) + fractionToTiles(playerZ[0]))/2)
 		);
 		createObjectGroup(group, 0);
 
 	}
 	else
 	{
 		passageMaker(
 			fractionToTiles(playerX[i]),
 			fractionToTiles(playerZ[i]),
 			fractionToTiles(playerX[i+1]),
 			fractionToTiles(playerZ[i+1]),
 			6, -2, -2, 4, clShallows, undefined, -4);
 
 		log("Creating animals in shallows...");
 		var group = new SimpleGroup(
 			[new SimpleObject(oElephant, 2,3, 0,4)],
 			true, clFood, round((fractionToTiles(playerX[i]) + fractionToTiles(playerX[i+1]))/2), round((fractionToTiles(playerZ[i]) + fractionToTiles(playerZ[i+1]))/2)
 		);
 		createObjectGroup(group, 0);
 
 		var group = new SimpleGroup(
 			[new SimpleObject(oWildebeest, 5,6, 0,4)],
 			true, clFood, round((fractionToTiles(playerX[i]) + fractionToTiles(playerX[i+1]))/2), round((fractionToTiles(playerZ[i]) + fractionToTiles(playerZ[i+1]))/2)
 		);
 		createObjectGroup(group, 0);
 
 	}
 
 }
 paintTerrainBasedOnHeight(-6, 2, 1, tWater);
 
 log("Creating bumps...");
 placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1);
 painter = new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2);
 createAreas(
 	placer,
 	painter,
 	avoidClasses(clWater, 2, clPlayer, 20),
 	scaleByMapSize(100, 200)
 );
 
 log("Creating hills...");
 placer = new ClumpPlacer(scaleByMapSize(20, 150), 0.2, 0.1, 1);
 terrainPainter = new LayeredPainter(
 	[tGrass, tCliff, tHill],		// terrains
 	[1, 2]								// widths
 );
 elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 35, 3);
 createAreas(
 	placer,
 	[terrainPainter, elevationPainter, paintClass(clHill)],
 	avoidClasses(clPlayer, 20, clHill, 15, clWater, 3),
 	scaleByMapSize(1, 4) * numPlayers
 );
 
 // calculate desired number of trees for map (based on size)
 var MIN_TREES = 160;
 var MAX_TREES = 900;
 var P_FOREST = 0.02;
 
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 var numForest = totalTrees * P_FOREST;
 var numStragglers = totalTrees * (1.0 - P_FOREST);
 
 log("Creating forests...");
 var types = [
 	[[tForestFloor, tGrass, pForest], [tForestFloor, pForest]]
 ];	// some variation
 
 var size = numForest / (0.5 * scaleByMapSize(2,8) * numPlayers);
 var num = floor(size / types.length);
 for (var i = 0; i < types.length; ++i)
 {
 	placer = new ClumpPlacer(numForest / num, 0.1, 0.1, 1);
 	painter = new LayeredPainter(
 		types[i],		// terrains
 		[2]											// widths
 		);
 	createAreas(
 		placer,
 		[painter, paintClass(clForest)],
 		avoidClasses(clPlayer, 20, clForest, 10, clHill, 0, clWater, 2),
 		num
 	);
 }
 
 RMS.SetProgress(50);
 
 log("Creating dirt patches...");
 var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
 for (var i = 0; i < sizes.length; i++)
 {
 	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
 	painter = new LayeredPainter(
 		[[tGrass,tDirtRocksA],[tDirtRocksA,tDirtRocksB], [tDirtRocksB,tDirtRocksC]], 		// terrains
 		[1,1]															// widths
 	);
 	createAreas(
 		placer,
 		[painter, paintClass(clDirt)],
 		avoidClasses(clWater, 3, clForest, 0, clHill, 0, clPlayer, 20),
 		scaleByMapSize(15, 45)
 	);
 }
 
 log("Creating grass patches...");
 var sizes = [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)];
 for (var i = 0; i < sizes.length; i++)
 {
 	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
 	painter = new TerrainPainter(tGrassPatch);
 	createAreas(
 		placer,
 		painter,
 		avoidClasses(clWater, 3, clForest, 0, clHill, 0, clPlayer, 20),
 		scaleByMapSize(15, 45)
 	);
 }
 RMS.SetProgress(55);
 
 log("Creating stone mines...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clRock, 10, clHill, 1),
 	scaleByMapSize(4,16), 100
 );
 
 log("Creating small stone quarries...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clRock, 10, clHill, 1),
 	scaleByMapSize(4,16), 100
 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 1),
 	scaleByMapSize(4,16), 100
 );
 
 RMS.SetProgress(65);
 
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockMedium, 1,3, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0),
 	scaleByMapSize(16, 262), 50
 );
 
 log("Creating large decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0),
 	scaleByMapSize(8, 131), 50
 );
 
 RMS.SetProgress(70);
 
 log("Creating wildebeest...");
 group = new SimpleGroup(
 	[new SimpleObject(oWildebeest, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 5),
 	3 * numPlayers, 50
 );
 
 RMS.SetProgress(75);
 
 log("Creating gazelle...");
 group = new SimpleGroup(
 	[new SimpleObject(oGazelle, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 5),
 	3 * numPlayers, 50
 );
 
 log("Creating elephant...");
 group = new SimpleGroup(
 	[new SimpleObject(oElephant, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 5),
 	3 * numPlayers, 50
 );
 
 log("Creating giraffe...");
 group = new SimpleGroup(
 	[new SimpleObject(oGiraffe, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 5),
 	3 * numPlayers, 50
 );
 
 log("Creating zebra...");
 group = new SimpleGroup(
 	[new SimpleObject(oZebra, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 5),
 	3 * numPlayers, 50
 );
 
 log("Creating fish...");
 group = new SimpleGroup(
 	[new SimpleObject(oFish, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clFood, 20), stayClasses(clWater, 6)],
 	25 * numPlayers, 60
 );
 
 log("Creating berry bush...");
 group = new SimpleGroup(
 	[new SimpleObject(oBerryBush, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 10),
 	randIntInclusive(1, 4) * numPlayers + 2, 50
 );
 
 RMS.SetProgress(85);
 
 log("Creating straggler trees...");
 var types = [oBaobab, oBaobab, oBaobab, oFig];	// some variation
 var num = floor(numStragglers / types.length);
 for (var i = 0; i < types.length; ++i)
 {
 	group = new SimpleGroup(
 		[new SimpleObject(types[i], 1,1, 0,3)],
 		true, clForest
 	);
 	createObjectGroupsDeprecated(group, 0,
 		avoidClasses(clWater, 5, clForest, 1, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6),
 		num
 	);
 }
 
 var planetm = 4;
 log("Creating small grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)]
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 2, clHill, 2, clPlayer, 2),
 	planetm * scaleByMapSize(13, 200)
 );
 
 RMS.SetProgress(90);
 
 log("Creating large grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aGrass, 2,4, 0,1.8, -PI/8,PI/8), new SimpleObject(aGrassShort, 3,6, 1.2,2.5, -PI/8,PI/8)]
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clHill, 2, clPlayer, 2, clForest, 0),
 	planetm * scaleByMapSize(13, 200)
 );
 
 RMS.SetProgress(95);
 
 log("Creating bushes...");
 group = new SimpleGroup(
 	[new SimpleObject(aBushMedium, 1,2, 0,2), new SimpleObject(aBushSmall, 2,4, 0,2)]
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 2, clHill, 1, clPlayer, 1),
 	planetm * scaleByMapSize(13, 200), 50
 );
 
 setSkySet("sunny");
 
 setSunRotation(randFloat(0, TWO_PI));
 setSunElevation(randFloat(PI/ 5, PI / 4));
 setWaterColor(0.478,0.42,0.384);				// greyish
 setWaterTint(0.58,0.22,0.067);				// reddish
 setWaterMurkiness(0.87);
 setWaterWaviness(0.5);
 setWaterType("clap");
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/survivalofthefittest.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/survivalofthefittest.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/survivalofthefittest.js	(revision 20149)
@@ -1,250 +1,242 @@
 RMS.LoadLibrary("rmgen");
 RMS.LoadLibrary("rmbiome");
 
 setSelectedBiome();
 
 const tMainTerrain = g_Terrains.mainTerrain;
 const tForestFloor1 = g_Terrains.forestFloor1;
 const tForestFloor2 = g_Terrains.forestFloor2;
 const tCliff = g_Terrains.cliff;
 const tHill = g_Terrains.hill;
 const tTier1Terrain = g_Terrains.tier1Terrain;
 const tTier2Terrain = g_Terrains.tier2Terrain;
 const tTier3Terrain = g_Terrains.tier3Terrain;
 const tTier4Terrain = g_Terrains.tier4Terrain;
 
 const oTree1 = g_Gaia.tree1;
 const oTree2 = g_Gaia.tree2;
 const oTree3 = g_Gaia.tree3;
 const oTree4 = g_Gaia.tree4;
 const oTree5 = g_Gaia.tree5;
 
 const aGrass = g_Decoratives.grass;
 const aGrassShort = g_Decoratives.grassShort;
 const aRockLarge = g_Decoratives.rockLarge;
 const aRockMedium = g_Decoratives.rockMedium;
 const aBushMedium = g_Decoratives.bushMedium;
 const aBushSmall = g_Decoratives.bushSmall;
 const aWaypointFlag = "actor|props/special/common/waypoint_flag.xml";
 
 const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
 const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
 
 const oTreasureSeeker = "skirmish/units/default_support_female_citizen";
 const oCivicCenter = "skirmish/structures/default_civil_centre";
 const oCitizenInfantry = "skirmish/units/default_infantry_melee_b";
 
 const triggerPointAttacker = "special/trigger_point_A";
 const triggerPointTreasures = [
 	"special/trigger_point_B",
 	"special/trigger_point_C",
 	"special/trigger_point_D"
 ];
 
 InitMap();
 
 var numPlayers = getNumPlayers();
 var mapSize = getMapSize();
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clDirt = createTileClass();
 var clBaseResource = createTileClass();
 var clLand = createTileClass();
 var clWomen = createTileClass();
 
 initTerrain(tMainTerrain);
 
 var ix = Math.round(fractionToTiles(0.5));
 var iz = Math.round(fractionToTiles(0.5));
 
 // Create the main treasure area in the middle of the map
 createArea(
 	new ClumpPlacer(mapSize * mapSize * scaleByMapSize(0.065, 0.09), 0.7, 0.1, 10, ix, iz),
 	[
 		new LayeredPainter([tMainTerrain, tMainTerrain], [3]),
 		new SmoothElevationPainter(ELEVATION_SET, 3, 3),
 		paintClass(clLand)
 	],
 	null);
 
-var playerIDs = sortAllPlayers();
+var [playerIDs, playerX, playerZ, playerAngle, startAngle] = radialPlayerPlacement(0.3);
 
-// place players
-var playerX = new Array(numPlayers);
-var playerZ = new Array(numPlayers);
 var attackerX = new Array(numPlayers);
 var attackerZ = new Array(numPlayers);
-var playerAngle = new Array(numPlayers);
 
-var startAngle = randFloat(0, 2 * PI);
 for (let  i = 0; i < numPlayers; ++i)
 {
-	playerAngle[i] = startAngle + i * 2 * PI / numPlayers;
-	playerX[i] = 0.5 + 0.3*cos(playerAngle[i]);
-	playerZ[i] = 0.5 + 0.3*sin(playerAngle[i]);
 	attackerX[i] = 0.5 + 0.45*cos(playerAngle[i]);
 	attackerZ[i] = 0.5 + 0.45*sin(playerAngle[i]);
 }
 
 for (let i = 0; i < numPlayers; ++i)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15, 25);
 
 	// place the attacker spawning trigger point
 	var ax = round(fractionToTiles(attackerX[i]));
 	var az = round(fractionToTiles(attackerZ[i]));
 	placeObject(ax, az, triggerPointAttacker, id, PI);
 	placeObject(ax, az, aWaypointFlag, 0, PI/2);
 	addToClass(ax, az, clPlayer);
 	addToClass(round(fractionToTiles((attackerX[i] + playerX[i]) / 2)), round(fractionToTiles((attackerZ[i] + playerZ[i]) / 2)), clPlayer);
 
 	// get the x and z in tiles
 	let fx = fractionToTiles(playerX[i]);
 	let fz = fractionToTiles(playerZ[i]);
 	let ix = round(fx);
 	let iz = round(fz);
 
 	addToClass(ix, iz, clPlayer);
 	addToClass(ix+5, iz, clPlayer);
 	addToClass(ix, iz+5, clPlayer);
 	addToClass(ix-5, iz, clPlayer);
 	addToClass(ix, iz-5, clPlayer);
 
 	// Place default civ starting entities
 	var uDist = 6;
 	var uSpace = 2;
 	placeObject(fx, fz, oCivicCenter, id, BUILDING_ORIENTATION);
 	var uAngle = BUILDING_ORIENTATION - PI / 2;
 	var count = 4;
 	for (let numberofentities = 0; numberofentities < count; ++numberofentities)
 	{
 		var ux = fx + uDist * cos(uAngle) + numberofentities * uSpace * cos(uAngle + PI/2) - (0.75 * uSpace * floor(count / 2) * cos(uAngle + PI/2));
 		var uz = fz + uDist * sin(uAngle) + numberofentities * uSpace * sin(uAngle + PI/2) - (0.75 * uSpace * floor(count / 2) * sin(uAngle + PI/2));
 		placeObject(ux, uz, oCitizenInfantry, id, uAngle);
 	}
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 
 	var tang = startAngle + (i + 0.5) * 2 * PI / numPlayers;
 
 	var placer = new PathPlacer(
 		fractionToTiles(0.5),
 		fractionToTiles(0.5),
 		fractionToTiles(0.5 + 0.5 * Math.cos(tang)),
 		fractionToTiles(0.5 + 0.5 * Math.sin(tang)),
 		scaleByMapSize(14, 24),
 		0.4,
 		3 * scaleByMapSize(1, 3),
 		0.2,
 		0.05);
 
 	createArea(
 		placer,
 		[
 			new LayeredPainter([tMainTerrain, tMainTerrain], [1]),
 			new SmoothElevationPainter(ELEVATION_SET, 3, 4)
 		],
 		null);
 
 	var femaleLocation = getTIPIADBON([ix, iz], [mapSize / 2, mapSize / 2], [-3 , 3.5], 1, 3);
 	if (femaleLocation !== undefined)
 	{
 		placeObject(femaleLocation[0], femaleLocation[1], oTreasureSeeker, id, playerAngle[i] + PI);
 		addToClass(floor(femaleLocation[0]), floor(femaleLocation[1]), clWomen);
 	}
 }
 
 paintTerrainBasedOnHeight(3.12, 29, 1, tCliff);
 paintTileClassBasedOnHeight(3.12, 29, 1, clHill);
 
 for (let triggerPointTreasure of triggerPointTreasures)
 	createObjectGroupsDeprecated(
 		new SimpleGroup([new SimpleObject(triggerPointTreasure, 1, 1, 0, 0)], true, clWomen),
 		0,
 		[avoidClasses(clForest, 5, clPlayer, 5, clHill, 5), stayClasses(clLand, 5)],
 		scaleByMapSize(40, 140), 100
 	);
 
 createBumps(stayClasses(clLand, 5));
 
 createForests(
 	[tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
 	[avoidClasses(clPlayer, 20, clForest, 5, clHill, 0, clBaseResource,2, clWomen, 5), stayClasses(clLand, 4)],
 	clForest,
 	1,
 	...rBiomeTreeCount(1));
 
 if (randBool())
 	createHills(
 		[tMainTerrain, tCliff, tHill],
 		[avoidClasses(clPlayer, 20, clHill, 5, clBaseResource, 3, clWomen, 5), stayClasses(clLand, 5)],
 		clHill,
 		scaleByMapSize(10, 60) * numPlayers);
 else
 	createMountains(
 		tCliff,
 		[avoidClasses(clPlayer, 20, clHill, 5, clBaseResource, 3, clWomen, 5), stayClasses(clLand, 5)],
 		clHill,
 		scaleByMapSize(10, 60) * numPlayers);
 
 createHills(
 	[tCliff, tCliff, tHill],
 	avoidClasses(clPlayer, 20, clHill, 5, clBaseResource, 3, clWomen, 5, clLand, 5),
 	clHill,
 	scaleByMapSize(15, 90) * numPlayers,
 	undefined,
 	undefined,
 	undefined,
 	undefined,
 	55);
 
 RMS.SetProgress(50);
 
 log("Creating dirt patches...");
 createLayeredPatches(
 	[scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
 	[[tMainTerrain, tTier1Terrain], [tTier1Terrain, tTier2Terrain], [tTier2Terrain, tTier3Terrain]],
 	[1, 1],
 	[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12, clWomen, 5), stayClasses(clLand, 5)]
 );
 
 log("Creating grass patches...");
 createPatches(
 	[scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
 	tTier4Terrain,
 	[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12, clWomen, 5), stayClasses(clLand, 5)]
 );
 
 var planetm = 1;
 if (currentBiome() == "tropic")
 	planetm = 8;
 
 createDecoration(
 	[
 		[new SimpleObject(aRockMedium, 1, 3, 0, 1)],
 		[new SimpleObject(aRockLarge, 1, 2, 0, 1), new SimpleObject(aRockMedium, 1, 3, 0, 2)],
 		[new SimpleObject(aGrassShort, 1, 2, 0, 1, -PI/8, PI/8)],
 		[new SimpleObject(aGrass, 2,4, 0, 1.8, -PI/8, PI/8), new SimpleObject(aGrassShort, 3,6, 1.2, 2.5, -PI/8, PI/8)],
 		[new SimpleObject(aBushMedium, 1, 2, 0, 2), new SimpleObject(aBushSmall, 2, 4, 0, 2)]
 	],
 	[
 		scaleByMapSize(16, 262),
 		scaleByMapSize(8, 131),
 		planetm * scaleByMapSize(13, 200),
 		planetm * scaleByMapSize(13, 200),
 		planetm * scaleByMapSize(13, 200)
 	],
 	[avoidClasses(clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 5)]
 );
 
 log("Creating straggler trees...");
 createStragglerTrees(
 	[oTree1, oTree2, oTree4, oTree3],
 	[avoidClasses(clForest, 7, clHill, 1, clPlayer, 9), stayClasses(clLand, 7)]);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/unknown_land.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/unknown_land.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/unknown_land.js	(revision 20149)
@@ -1,1654 +1,1585 @@
 RMS.LoadLibrary("rmgen");
 RMS.LoadLibrary("rmbiome");
 
 TILE_CENTERED_HEIGHT_MAP = true;
 
 setSelectedBiome();
 
 const tMainTerrain = g_Terrains.mainTerrain;
 const tForestFloor1 = g_Terrains.forestFloor1;
 const tForestFloor2 = g_Terrains.forestFloor2;
 const tCliff = g_Terrains.cliff;
 const tTier1Terrain = g_Terrains.tier1Terrain;
 const tTier2Terrain = g_Terrains.tier2Terrain;
 const tTier3Terrain = g_Terrains.tier3Terrain;
 const tHill = g_Terrains.hill;
 const tDirt = g_Terrains.dirt;
 const tRoad = g_Terrains.road;
 const tRoadWild = g_Terrains.roadWild;
 const tTier4Terrain = g_Terrains.tier4Terrain;
 const tShoreBlend = g_Terrains.shoreBlend;
 const tShore = g_Terrains.shore;
 const tWater = g_Terrains.water;
 
 const oTree1 = g_Gaia.tree1;
 const oTree2 = g_Gaia.tree2;
 const oTree3 = g_Gaia.tree3;
 const oTree4 = g_Gaia.tree4;
 const oTree5 = g_Gaia.tree5;
 const oFruitBush = g_Gaia.fruitBush;
 const oMainHuntableAnimal = g_Gaia.mainHuntableAnimal;
 const oFish = g_Gaia.fish;
 const oSecondaryHuntableAnimal = g_Gaia.secondaryHuntableAnimal;
 const oStoneLarge = g_Gaia.stoneLarge;
 const oStoneSmall = g_Gaia.stoneSmall;
 const oMetalLarge = g_Gaia.metalLarge;
 const oWood = "gaia/special_treasure_wood";
 
 const aGrass = g_Decoratives.grass;
 const aGrassShort = g_Decoratives.grassShort;
 const aReeds = g_Decoratives.reeds;
 const aLillies = g_Decoratives.lillies;
 const aRockLarge = g_Decoratives.rockLarge;
 const aRockMedium = g_Decoratives.rockMedium;
 const aBushMedium = g_Decoratives.bushMedium;
 const aBushSmall = g_Decoratives.bushSmall;
 
 const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
 const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 const mapArea = mapSize*mapSize;
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clSettlement = createTileClass();
 var clLand = createTileClass();
 var clShallow = createTileClass();
 
 initTerrain(tWater);
 
 var md = randIntInclusive(2,13);
 var needsAdditionalWood = false;
 //*****************************************************************************************************************************
 if (md == 2) //continent
 {
-	var playerIDs = sortAllPlayers();
-
-	// place players
-	var playerX = new Array(numPlayers);
-	var playerZ = new Array(numPlayers);
-	var playerAngle = new Array(numPlayers);
+	var [playerIDs, playerX, playerZ, playerAngle] = radialPlayerPlacement(0.25);
 
-	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 (randBool(1/3)) // 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
 {
 	var playerIDs = primeSortAllPlayers();
 
 	// 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 = randIntInclusive(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(randIntInclusive(16,24),randIntInclusive(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(randIntInclusive(16,24),randIntInclusive(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 = randIntInclusive(1,7);
 	if (mdd2 == 1)
 	{
 		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)*randIntInclusive(8,14)
 		);
 	}
 	else if (mdd2 == 2)
 	{
 		log("Creating extentions...");
 		placer = new ClumpPlacer(randIntInclusive(scaleByMapSize(13,24),scaleByMapSize(24,45))*randIntInclusive(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)*randIntInclusive(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);
 		}
 	}
 
 	var playerIDs = primeSortAllPlayers();
 
 	// 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 = randIntInclusive(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);
 		}
 	}
 
 	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));
 
 	log("Creating the shallows of the main river");
 
 	for (var i = 0; i <= randIntInclusive(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 (randBool())
 	{
 		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);
 		}
 
 		log("Creating tributaries");
 
 		for (var i = 0; i <= randIntInclusive(8, (scaleByMapSize(12,20))); i++)
 		{
 			var cLocation = randFloat(0.05,0.95);
 			var tang = randFloat(PI*0.2, PI*0.8)*((randIntInclusive(0, 1)-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
 {
+	var [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
-	var playerIDs = sortAllPlayers();
-
-	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 = randIntInclusive(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);
 
 		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 (randBool(1/3) &&(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 = randIntInclusive(1,2);
 
 	var playerIDs = sortAllPlayers();
 
 	// 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 = randIntInclusive(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);
 						}
 					}
 				}
 			}
 		}
 	}
 
 	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 = randIntInclusive(1,5);
 	if (mdd3 == 1)
 	{
 		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)*randIntInclusive(8,14)
 		);
 	}
 	else if (mdd3 == 2)
 	{
 		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)*randIntInclusive(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);
 
 	var playerIDs = sortAllPlayers();
 
 	// 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
 {
-	var playerIDs = sortAllPlayers();
-
-	// 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 [playerIDs, playerX, playerZ, playerAngle] = radialPlayerPlacement();
 
 	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;
 
 	log("Creating lakes...");
 	var numLakes = scaleByMapSize(5, 16);
 	for (var i = 0; i < numLakes; ++i)
 	{
 		lakeAreaLen = lakeAreas.length;
 		if (!lakeAreaLen)
 			break;
 
 		chosenPoint = pickRandom(lakeAreas);
 
 		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
 {
-	var playerIDs = sortAllPlayers();
-
-	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 [playerIDs, playerX, playerZ, playerAngle] = radialPlayerPlacement();
 
 	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);
 		}
 	}
 
 	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 = randIntInclusive (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
 {
-	var playerIDs = sortAllPlayers();
-
-	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 [playerIDs, playerX, playerZ, playerAngle] = radialPlayerPlacement();
 
 	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
 {
-	var playerIDs = sortAllPlayers();
-
-	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 [playerIDs, playerX, playerZ, playerAngle] = radialPlayerPlacement();
 
 	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 + "...");
 
 	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);
 
 	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);
 }
 
 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)],
 	randIntInclusive(0,scaleByMapSize(200, 400))
 );
 
 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, randIntInclusive(6, 18)), stayClasses(clLand, 0)],
 	randIntInclusive(0, scaleByMapSize(4, 8))*randIntInclusive(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 (currentBiome() == "savanna")
 {
 	var MIN_TREES = floor(200*multiplier);
 	var MAX_TREES = floor(1250*multiplier);
 	var P_FOREST = 0;
 }
 else if (currentBiome() == "tropic")
 {
 	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);
 
 log("Creating forests...");
 var types = [
 	[[tForestFloor2, tMainTerrain, pForest1], [tForestFloor2, pForest1]],
 	[[tForestFloor1, tMainTerrain, pForest2], [tForestFloor1, pForest2]]
 ];	// some variation
 
 if (currentBiome() != "savanna")
 {
 	var size = numForest / (scaleByMapSize(3,6) * numPlayers);
 	var num = floor(size / types.length);
 	for (var i = 0; i < types.length; ++i)
 	{
 		placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), numForest / num, 0.5);
 		painter = new LayeredPainter(
 			types[i],		// terrains
 			[2]											// widths
 			);
 		createAreas(
 			placer,
 			[painter, paintClass(clForest)],
 			[avoidClasses(clPlayer, 20, clForest, randIntInclusive(5, 15), clHill, 0), stayClasses(clLand, 4)],
 			num
 		);
 	}
 }
 
 RMS.SetProgress(50);
 log("Creating dirt patches...");
 var sizes = [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)];
 var numb = 1;
 if (currentBiome() == "savanna")
 	numb = 3;
 for (var i = 0; i < sizes.length; i++)
 {
 	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
 	painter = new LayeredPainter(
 		[[tMainTerrain,tTier1Terrain],[tTier1Terrain,tTier2Terrain], [tTier2Terrain,tTier3Terrain]], 		// terrains
 		[1,1]															// widths
 	);
 	createAreas(
 		placer,
 		[painter, paintClass(clDirt)],
 		[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 7), stayClasses(clLand, 4)],
 		numb*scaleByMapSize(15, 45)
 	);
 }
 
 log("Creating grass patches...");
 var sizes = [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)];
 for (var i = 0; i < sizes.length; i++)
 {
 	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
 	painter = new 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...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 20, clRock, 10, clHill, 1), stayClasses(clLand, 4)],
 	randIntInclusive(scaleByMapSize(2,9),scaleByMapSize(9,40)), 100
 );
 
 log("Creating small stone quarries...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 20, clRock, 10, clHill, 1), stayClasses(clLand, 4)],
 	randIntInclusive(scaleByMapSize(2,9),scaleByMapSize(9,40)), 100
 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 1), stayClasses(clLand, 4)],
 	randIntInclusive(scaleByMapSize(2,9),scaleByMapSize(9,40)), 100
 );
 
 RMS.SetProgress(65);
 
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockMedium, 1,3, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	[avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 4)],
 	scaleByMapSize(16, 262), 50
 );
 
 log("Creating large decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	[avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 4)],
 	scaleByMapSize(8, 131), 50
 );
 RMS.SetProgress(70);
 
 log("Creating deer...");
 group = new SimpleGroup(
 	[new SimpleObject(oMainHuntableAnimal, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clWater, 0, clForest, 0, clPlayer, 20, clHill, 1, clFood, 20), stayClasses(clLand, 4)],
 	randIntInclusive(numPlayers+3, 5*numPlayers+4), 50
 );
 
 log("Creating berry bush...");
 group = new SimpleGroup(
 	[new SimpleObject(oFruitBush, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clWater, 0, clForest, 0, clPlayer, 20, clHill, 1, clFood, 20), stayClasses(clLand, 4)],
 	randIntInclusive(1, 4) * numPlayers + 2, 50
 );
 RMS.SetProgress(75);
 
 log("Creating sheep...");
 group = new SimpleGroup(
 	[new SimpleObject(oSecondaryHuntableAnimal, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clWater, 0, clForest, 0, clPlayer, 20, clHill, 1, clFood, 20), stayClasses(clLand, 4)],
 	randIntInclusive(numPlayers+3, 5*numPlayers+4), 50
 );
 
 log("Creating fish...");
 group = new SimpleGroup(
 	[new SimpleObject(oFish, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clLand, 5, clForest, 0, clPlayer, 0, clHill, 0, clFood, 20),
 	randIntInclusive(15, 40) * numPlayers, 60
 );
 RMS.SetProgress(85);
 
 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
 	);
 	createObjectGroupsDeprecated(group, 0,
 		[avoidClasses(clWater, 1, clForest, 7, clHill, 1, clPlayer, 0, clMetal, 6, clRock, 6), stayClasses(clLand, 4)],
 		num
 	);
 }
 
 var planetm = 1;
 if (currentBiome() == "tropic")
 	planetm = 8;
 
 log("Creating small grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)]
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clWater, 2, clHill, 2, clPlayer, 2, clDirt, 0), stayClasses(clLand, 4)],
 	planetm * scaleByMapSize(13, 200)
 );
 RMS.SetProgress(90);
 
 log("Creating large grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aGrass, 2,4, 0,1.8, -PI/8,PI/8), new SimpleObject(aGrassShort, 3,6, 1.2,2.5, -PI/8,PI/8)]
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clWater, 3, clHill, 2, clPlayer, 2, clDirt, 1, clForest, 0), stayClasses(clLand, 4)],
 	planetm * scaleByMapSize(13, 200)
 );
 RMS.SetProgress(95);
 
 log("Creating shallow flora...");
 group = new SimpleGroup(
 	[new SimpleObject(aLillies, 1,2, 0,2), new SimpleObject(aReeds, 2,4, 0,2)]
 );
 createObjectGroupsDeprecated(group, 0,
 	stayClasses(clShallow, 1),
 	60 * scaleByMapSize(13, 200), 80
 );
 
 log("Creating bushes...");
 group = new SimpleGroup(
 	[new SimpleObject(aBushMedium, 1,2, 0,2), new SimpleObject(aBushSmall, 2,4, 0,2)]
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clWater, 1, clHill, 1, clPlayer, 1, clDirt, 1), stayClasses(clLand, 3)],
 	planetm * scaleByMapSize(13, 200), 50
 );
 
 setSkySet(pickRandom(["cirrus", "cumulus", "sunny", "sunny 1", "mountainous", "stratus"]));
 setSunRotation(randFloat(0, TWO_PI));
 setSunElevation(randFloat(PI/ 5, PI / 3));
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/rhine_marshlands.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/rhine_marshlands.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/rhine_marshlands.js	(revision 20149)
@@ -1,416 +1,404 @@
 RMS.LoadLibrary("rmgen");
 
 const tGrass = ["temp_grass", "temp_grass", "temp_grass_d"];
 const tForestFloor = "temp_plants_bog";
 const tGrassA = "temp_grass_plants";
 const tGrassB = "temp_plants_bog";
 const tMud = "temp_mud_a";
 const tRoad = "temp_road";
 const tRoadWild = "temp_road_overgrown";
 const tShoreBlend = "temp_grass_plants";
 const tShore = "temp_plants_bog";
 const tWater = "temp_mud_a";
 
 const oBeech = "gaia/flora_tree_euro_beech";
 const oOak = "gaia/flora_tree_oak";
 const oBerryBush = "gaia/flora_bush_berry";
 const oDeer = "gaia/fauna_deer";
 const oHorse = "gaia/fauna_horse";
 const oWolf = "gaia/fauna_wolf";
 const oFish = "gaia/fauna_fish";
 const oRabbit = "gaia/fauna_rabbit";
 const oStoneLarge = "gaia/geology_stonemine_temperate_quarry";
 const oStoneSmall = "gaia/geology_stone_temperate";
 const oMetalLarge = "gaia/geology_metal_temperate_slabs";
 
 const aGrass = "actor|props/flora/grass_soft_small_tall.xml";
 const aGrassShort = "actor|props/flora/grass_soft_large.xml";
 const aRockLarge = "actor|geology/stone_granite_med.xml";
 const aRockMedium = "actor|geology/stone_granite_med.xml";
 const aReeds = "actor|props/flora/reeds_pond_lush_a.xml";
 const aLillies = "actor|props/flora/water_lillies.xml";
 const aBushMedium = "actor|props/flora/bush_medit_me.xml";
 const aBushSmall = "actor|props/flora/bush_medit_sm.xml";
 
 const pForestD = [tForestFloor + TERRAIN_SEPARATOR + oBeech, tForestFloor];
 const pForestP = [tForestFloor + TERRAIN_SEPARATOR + oOak, tForestFloor];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 const mapArea = mapSize*mapSize;
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clSettlement = createTileClass();
 
-var playerIDs = sortAllPlayers();
-
-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 [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 	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);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oBerryBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = radius - 4;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 	var hillSize = PI * radius * radius;
 	// create starting trees
 	var num = floor(hillSize / 100);
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = 12;
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oBeech, num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 
 RMS.SetProgress(15);
 
 log("Creating bumps...");
 placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1);
 painter = new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2);
 createAreas(
 	placer,
 	painter,
 	avoidClasses(clPlayer, 13),
 	scaleByMapSize(300, 800)
 );
 
 log("Creating marshes...");
 for (var i = 0; i < 7; i++)
 {
 	placer = new ChainPlacer(1, floor(scaleByMapSize(6, 12)), floor(scaleByMapSize(15, 60)), 0.8);
 	var terrainPainter = new LayeredPainter(
 		[tShoreBlend, tShore, tWater],		// terrains
 		[1,1]							// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -2, 3);
 	var waterAreas = createAreas(
 		placer,
 		[terrainPainter, elevationPainter, paintClass(clWater)],
 		avoidClasses(clPlayer, 20, clWater, round(scaleByMapSize(7,16)*randFloat(0.8,1.35))),
 		scaleByMapSize(4,20)
 	);
 }
 
 log("Creating reeds...");
 group = new SimpleGroup(
 	[new SimpleObject(aReeds, 5,10, 0,4), new SimpleObject(aLillies, 5,10, 0,4)], true
 );
 createObjectGroupsDeprecated(group, 0,
 	stayClasses(clWater, 1),
 	scaleByMapSize(400,2000), 100
 );
 waterAreas = [];
 
 RMS.SetProgress(40);
 
 log("Creating bumps...");
 placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1);
 painter = new SmoothElevationPainter(ELEVATION_MODIFY, 1, 2);
 createAreas(
 	placer,
 	painter,
 	stayClasses(clWater, 2),
 	scaleByMapSize(50, 100)
 );
 
 // calculate desired number of trees for map (based on size)
 const MIN_TREES = 500;
 const MAX_TREES = 2500;
 const P_FOREST = 0.7;
 
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 var numForest = totalTrees * P_FOREST;
 var numStragglers = totalTrees * (1.0 - P_FOREST);
 
 log("Creating forests...");
 var types = [
 	[[tForestFloor, tGrass, pForestD], [tForestFloor, pForestD]],
 	[[tForestFloor, tGrass, pForestP], [tForestFloor, pForestP]]
 ];	// some variation
 var size = numForest / (scaleByMapSize(3,6) * numPlayers);
 var num = floor(size / types.length);
 for (var i = 0; i < types.length; ++i)
 {
 	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), numForest / (num * floor(scaleByMapSize(2,4))), 1);
 	painter = new LayeredPainter(
 		types[i],		// terrains
 		[2]											// widths
 		);
 	createAreas(
 		placer,
 		[painter, paintClass(clForest)],
 		avoidClasses(clPlayer, 20, clWater, 0, clForest, 10, clHill, 1),
 		num
 	);
 }
 
 RMS.SetProgress(50);
 
 log("Creating mud patches...");
 var sizes = [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)];
 for (var i = 0; i < sizes.length; i++)
 {
 	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 1);
 	painter = new LayeredPainter(
 		[tGrassA, tGrassB, tMud], 		// terrains
 		[1,1]															// widths
 	);
 	createAreas(
 		placer,
 		[painter, paintClass(clDirt)],
 		avoidClasses(clWater, 1, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 8),
 		scaleByMapSize(15, 45)
 	);
 }
 
 log("Creating stone mines...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clWater, 0, clForest, 1, clPlayer, 20, clRock, 10, clHill, 1)],
 	scaleByMapSize(4,16), 100
 );
 
 log("Creating small stone quarries...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clWater, 0, clForest, 1, clPlayer, 20, clRock, 10, clHill, 1)],
 	scaleByMapSize(4,16), 100
 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clWater, 0, clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 1)],
 	scaleByMapSize(4,16), 100
 );
 
 RMS.SetProgress(60);
 
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockMedium, 1,3, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0),
 	scaleByMapSize(16, 262), 50
 );
 
 RMS.SetProgress(65);
 
 log("Creating large decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0),
 	scaleByMapSize(8, 131), 50
 );
 
 RMS.SetProgress(70);
 
 log("Creating deer...");
 group = new SimpleGroup(
 	[new SimpleObject(oDeer, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 0, clForest, 0, clPlayer, 20, clHill, 1, clFood, 13),
 	6 * numPlayers, 50
 );
 
 log("Creating horse...");
 group = new SimpleGroup(
 	[new SimpleObject(oHorse, 1,3, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 0, clForest, 0, clPlayer, 20, clHill, 1, clFood, 13),
 	3 * numPlayers, 50
 );
 
 RMS.SetProgress(75);
 
 log("Creating rabbit...");
 group = new SimpleGroup(
 	[new SimpleObject(oRabbit, 5,7, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 0, clForest, 0, clPlayer, 20, clHill, 1, clFood, 13),
 	6 * numPlayers, 50
 );
 
 log("Creating wolf...");
 group = new SimpleGroup(
 	[new SimpleObject(oWolf, 1,3, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 0, clForest, 0, clPlayer, 20, clHill, 1, clFood, 13),
 	3 * numPlayers, 50
 );
 
 log("Creating berry bush...");
 group = new SimpleGroup(
 	[new SimpleObject(oBerryBush, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 10),
 	randIntInclusive(1, 4) * numPlayers + 2, 50
 );
 
 RMS.SetProgress(80);
 
 log("Creating straggler trees...");
 var types = [oOak, oBeech];	// some variation
 var num = floor(numStragglers / types.length);
 for (var i = 0; i < types.length; ++i)
 {
 	group = new SimpleGroup(
 		[new SimpleObject(types[i], 1,1, 0,3)],
 		true, clForest
 	);
 	createObjectGroupsDeprecated(group, 0,
 		avoidClasses(clForest, 1, clHill, 1, clPlayer, 13, clMetal, 6, clRock, 6, clWater, 0),
 		num
 	);
 }
 
 RMS.SetProgress(85);
 
 log("Creating small grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)]
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 2, clHill, 2, clPlayer, 13, clDirt, 0),
 	scaleByMapSize(13, 200)
 );
 
 RMS.SetProgress(90);
 
 log("Creating large grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aGrass, 2,4, 0,1.8, -PI/8,PI/8), new SimpleObject(aGrassShort, 3,6, 1.2,2.5, -PI/8,PI/8)]
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clHill, 2, clPlayer, 13, clDirt, 1, clForest, 0),
 	scaleByMapSize(13, 200)
 );
 
 RMS.SetProgress(95);
 
 log("Creating bushes...");
 group = new SimpleGroup(
 	[new SimpleObject(aBushMedium, 1,2, 0,2), new SimpleObject(aBushSmall, 2,4, 0,2)]
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 1, clHill, 1, clPlayer, 13, clDirt, 1),
 	scaleByMapSize(13, 200), 50
 );
 
 setSkySet("cirrus");
 setWaterColor(0.753,0.635,0.345);				// muddy brown
 setWaterTint(0.161,0.514,0.635);				// clear blue for blueness
 setWaterMurkiness(0.8);
 setWaterWaviness(1.0);
 setWaterType("clap");
 
 setFogThickness(0.25);
 setFogFactor(0.6);
 
 setPPEffect("hdr");
 setPPSaturation(0.44);
 setPPBloom(0.3);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/rmgen/library.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/rmgen/library.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/rmgen/library.js	(revision 20149)
@@ -1,638 +1,658 @@
 const PI = Math.PI;
 const TWO_PI = 2 * Math.PI;
 const TERRAIN_SEPARATOR = "|";
 const SEA_LEVEL = 20.0;
 const CELL_SIZE = 4;
 const HEIGHT_UNITS_PER_METRE = 92;
 const MIN_MAP_SIZE = 128;
 const MAX_MAP_SIZE = 512;
 const MAP_BORDER_WIDTH = 3;
 const FALLBACK_CIV = "athen";
 /**
  * Constants needed for heightmap_manipulation.js
  */
 const MAX_HEIGHT_RANGE = 0xFFFF / HEIGHT_UNITS_PER_METRE; // Engine limit, Roughly 700 meters
 const MIN_HEIGHT = - SEA_LEVEL;
 const MAX_HEIGHT = MAX_HEIGHT_RANGE - SEA_LEVEL;
 // Default angle for buildings
 const BUILDING_ORIENTATION = - PI / 4;
 
 function fractionToTiles(f)
 {
 	return g_Map.size * f;
 }
 
 function tilesToFraction(t)
 {
 	return t / g_Map.size;
 }
 
 function fractionToSize(f)
 {
 	return getMapArea() * f;
 }
 
 function sizeToFraction(s)
 {
 	return s / getMapArea();
 }
 
 function scaleByMapSize(min, max)
 {
 	return min + (max - min) * (g_Map.size - MIN_MAP_SIZE) / (MAX_MAP_SIZE - MIN_MAP_SIZE);
 }
 
 function cos(x)
 {
 	return Math.cos(x);
 }
 
 function sin(x)
 {
 	return Math.sin(x);
 }
 
 function abs(x) {
 	return Math.abs(x);
 }
 
 function round(x)
 {
 	return Math.round(x);
 }
 
 function lerp(a, b, t)
 {
 	return a + (b-a) * t;
 }
 
 function sqrt(x)
 {
 	return Math.sqrt(x);
 }
 
 function ceil(x)
 {
 	return Math.ceil(x);
 }
 
 function floor(x)
 {
 	return Math.floor(x);
 }
 
 function max(a, b)
 {
 	return a > b ? a : b;
 }
 
 function min(a, b)
 {
 	return a < b ? a : b;
 }
 
 /**
  * Retries the given function with those arguments as often as specified.
  */
 function retryPlacing(placeFunc, placeArgs, retryFactor, amount, getResult, behaveDeprecated = false)
 {
 	if (behaveDeprecated && !(placeArgs.placer instanceof SimpleGroup || placeArgs.placer instanceof RandomGroup))
 		warn("Deprecated version of createFoo should only be used for SimpleGroup and RandomGroup placers!");
 
 	let maxFail = amount * retryFactor;
 
 	let results = [];
 	let good = 0;
 	let bad = 0;
 
 	while (good < amount && bad <= maxFail)
 	{
 		let result = placeFunc(placeArgs);
 
 		if (result !== undefined || behaveDeprecated)
 		{
 			++good;
 			if (getResult)
 				results.push(result);
 		}
 		else
 			++bad;
 	}
 	return getResult ? results : good;
 }
 
 /**
  * Helper function for randomly placing areas and groups on the map.
  */
 function randomizePlacerCoordinates(placer, halfMapSize)
 {
 	if (!!g_MapSettings.CircularMap)
 	{
 		// Polar coordinates
 		// Uniformly distributed on the disk
 		let r = halfMapSize * Math.sqrt(randFloat(0, 1));
 		let theta = randFloat(0, 2 * PI);
 		placer.x = Math.floor(r * Math.cos(theta)) + halfMapSize;
 		placer.z = Math.floor(r * Math.sin(theta)) + halfMapSize;
 	}
 	else
 	{
 		// Rectangular coordinates
 		placer.x = randIntExclusive(0, g_Map.size);
 		placer.z = randIntExclusive(0, g_Map.size);
 	}
 }
 
 /**
  * Helper function for randomly placing areas and groups in the given areas.
  */
 function randomizePlacerCoordinatesFromAreas(placer, areas)
 {
 	let pt = pickRandom(pickRandom(areas).points);
 	placer.x = pt.x;
 	placer.z = pt.z;
 }
 
 // TODO this is a hack to simulate the old behaviour of those functions
 // until all old maps are changed to use the correct version of these functions
 function createObjectGroupsDeprecated(placer, player, constraint, amount, retryFactor = 10)
 {
 	return createObjectGroups(placer, player, constraint, amount, retryFactor, true);
 }
 
 function createObjectGroupsByAreasDeprecated(placer, player, constraint, amount, retryFactor, areas)
 {
 	return createObjectGroupsByAreas(placer, player, constraint, amount, retryFactor, areas, true);
 }
 
 /**
  * Attempts to place the given number of areas in random places of the map.
  * Returns actually placed areas.
  */
 function createAreas(centeredPlacer, painter, constraint, amount, retryFactor = 10, behaveDeprecated = false)
 {
 	let placeFunc = function (args) {
 		randomizePlacerCoordinates(args.placer, args.halfMapSize);
 		return g_Map.createArea(args.placer, args.painter, args.constraint);
 	};
 
 	let args = {
 		"placer": centeredPlacer,
 		"painter": painter,
 		"constraint": constraint,
 		"halfMapSize": g_Map.size / 2
 	};
 
 	return retryPlacing(placeFunc, args, retryFactor, amount, true, behaveDeprecated);
 }
 
 /**
  * Attempts to place the given number of areas in random places of the given areas.
  * Returns actually placed areas.
  */
 function createAreasInAreas(centeredPlacer, painter, constraint, amount, retryFactor, areas, behaveDeprecated = false)
 {
 	if (!areas.length)
 		return [];
 
 	let placeFunc = function (args) {
 		randomizePlacerCoordinatesFromAreas(args.placer, args.areas);
 		return g_Map.createArea(args.placer, args.painter, args.constraint);
 	};
 
 	let args = {
 		"placer": centeredPlacer,
 		"painter": painter,
 		"constraint": constraint,
 		"areas": areas,
 		"halfMapSize": g_Map.size / 2
 	};
 
 	return retryPlacing(placeFunc, args, retryFactor, amount, true, behaveDeprecated);
 }
 
 /**
  * Attempts to place the given number of groups in random places of the map.
  * Returns the number of actually placed groups.
  */
 function createObjectGroups(placer, player, constraint, amount, retryFactor = 10, behaveDeprecated = false)
 {
 	let placeFunc = function (args) {
 		randomizePlacerCoordinates(args.placer, args.halfMapSize);
 		return createObjectGroup(args.placer, args.player, args.constraint);
 	};
 
 	let args = {
 		"placer": placer,
 		"player": player,
 		"constraint": constraint,
 		"halfMapSize": g_Map.size / 2 - 3
 	};
 
 	return retryPlacing(placeFunc, args, retryFactor, amount, false, behaveDeprecated);
 }
 
 /**
  * Attempts to place the given number of groups in random places of the given areas.
  * Returns the number of actually placed groups.
  */
 function createObjectGroupsByAreas(placer, player, constraint, amount, retryFactor, areas, behaveDeprecated = false)
 {
 	if (!areas.length)
 		return 0;
 
 	let placeFunc = function (args) {
 		randomizePlacerCoordinatesFromAreas(args.placer, args.areas);
 		return createObjectGroup(args.placer, args.player, args.constraint);
 	};
 
 	let args = {
 		"placer": placer,
 		"player": player,
 		"constraint": constraint,
 		"areas": areas
 	};
 
 	return retryPlacing(placeFunc, args, retryFactor, amount, false, behaveDeprecated);
 }
 
 function createTerrain(terrain)
 {
 	if (!(terrain instanceof Array))
 		return createSimpleTerrain(terrain);
 
 	return new RandomTerrain(terrain.map(t => createTerrain(t)));
 }
 
 function createSimpleTerrain(terrain)
 {
 	if (typeof(terrain) != "string")
 		throw("createSimpleTerrain expects string as input, received "+terrain);
 
 	// Split string by pipe | character, this allows specifying terrain + tree type in single string
 	let params = terrain.split(TERRAIN_SEPARATOR, 2);
 
 	if (params.length != 2)
 		return new SimpleTerrain(terrain);
 
 	return new SimpleTerrain(params[0], params[1]);
 }
 
 function placeObject(x, z, type, player, angle)
 {
 	if (g_Map.validT(x, z, MAP_BORDER_WIDTH))
 		g_Map.addObject(new Entity(type, player, x, z, angle));
 }
 
 function placeTerrain(x, z, terrain)
 {
 	// convert terrain param into terrain object
 	g_Map.placeTerrain(x, z, createTerrain(terrain));
 }
 
 function initTerrain(tileClass)
 {
 	g_Map.initTerrain(createTerrain(tileClass));
 }
 
 function isCircularMap()
 {
 	return !!g_MapSettings.CircularMap;
 }
 
 function getMapBaseHeight()
 {
 	return g_MapSettings.BaseHeight || 0;
 }
 
 function createTileClass()
 {
 	return g_Map.createTileClass();
 }
 
 function getTileClass(id)
 {
 	if (!g_Map.validClass(id))
 		return undefined;
 
 	return g_Map.tileClasses[id];
 }
 
 function createArea(placer, painter, constraint)
 {
 	return g_Map.createArea(placer, painter, constraint);
 }
 
 function createObjectGroup(placer, player, constraint)
 {
 	return g_Map.createObjectGroup(placer, player, constraint);
 }
 
 function getMapSize()
 {
 	return g_Map.size;
 }
 
 function getMapArea()
 {
 	return g_Map.size * g_Map.size;
 }
 
 function getNumPlayers()
 {
 	return g_MapSettings.PlayerData.length - 1;
 }
 
 function getCivCode(player)
 {
 	if (g_MapSettings.PlayerData[player+1].Civ)
 		return g_MapSettings.PlayerData[player+1].Civ;
 
 	warn("undefined civ specified for player " + (player + 1) + ", falling back to '" + FALLBACK_CIV + "'");
 	return FALLBACK_CIV;
 }
 
 function areAllies(player1, player2)
 {
 	if (g_MapSettings.PlayerData[player1+1].Team === undefined ||
 		g_MapSettings.PlayerData[player2+1].Team === undefined ||
 		g_MapSettings.PlayerData[player2+1].Team == -1 ||
 		g_MapSettings.PlayerData[player1+1].Team == -1)
 		return false;
 
 	return g_MapSettings.PlayerData[player1+1].Team === g_MapSettings.PlayerData[player2+1].Team;
 }
 
 function getPlayerTeam(player)
 {
 	if (g_MapSettings.PlayerData[player+1].Team === undefined)
 		return -1;
 
 	return g_MapSettings.PlayerData[player+1].Team;
 }
 
 /**
  * Sorts an array of player IDs by team index. Players without teams come first.
  * Randomize order for players of the same team.
  */
 function sortPlayers(playerIndices)
 {
 	return shuffleArray(playerIndices).sort((p1, p2) => getPlayerTeam(p1 - 1) - getPlayerTeam(p2 - 1));
 }
 
 /**
  * Mix player indices but sort by team.
  *
  * @returns {Array} - every item is an array of player indices
  */
 function sortAllPlayers()
 {
 	let playerIDs = [];
 	for (let i = 0; i < getNumPlayers(); ++i)
 		playerIDs.push(i+1);
 
 	return sortPlayers(playerIDs);
 }
 
 function primeSortPlayers(playerIndices)
 {
 	if (!playerIndices.length)
 		return [];
 
 	let prime = [];
 	for (let i = 0; i < Math.ceil(playerIndices.length / 2); ++i)
 	{
 		prime.push(playerIndices[i]);
 		prime.push(playerIndices[playerIndices.length - 1 - i]);
 	}
 
 	return prime;
 }
 
 function primeSortAllPlayers()
 {
 	return primeSortPlayers(sortAllPlayers());
 }
 
+function radialPlayerPlacement(percentRadius = 0.35)
+{
+	let playerIDs = sortAllPlayers();
+
+	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 + percentRadius * Math.cos(playerAngle[i]);
+		playerZ[i] = 0.5 + percentRadius * Math.sin(playerAngle[i]);
+	}
+
+	return [playerIDs, playerX, playerZ, playerAngle, startAngle];
+}
+
 function getStartingEntities(player)
 {
 	let civ = getCivCode(player);
 
 	if (!g_CivData[civ] || !g_CivData[civ].StartEntities || !g_CivData[civ].StartEntities.length)
 	{
 		warn("Invalid or unimplemented civ '"+civ+"' specified, falling back to '" + FALLBACK_CIV + "'");
 		civ = FALLBACK_CIV;
 	}
 
 	return g_CivData[civ].StartEntities;
 }
 
 function getHeight(x, z)
 {
 	return g_Map.getHeight(x, z);
 }
 
 function setHeight(x, z, height)
 {
 	g_Map.setHeight(x, z, height);
 }
 
 /**
  *	Utility functions for classes
  */
 
 /**
  * Add point to given class by id
  */
 function addToClass(x, z, id)
 {
 	let tileClass = getTileClass(id);
 
 	if (tileClass !== null)
 		tileClass.add(x, z);
 }
 
 /**
  * Remove point from the given class by id
  */
 function removeFromClass(x, z, id)
 {
 	let tileClass = getTileClass(id);
 
 	if (tileClass !== null)
 		tileClass.remove(x, z);
 }
 
 /**
  * Create a painter for the given class
  */
 function paintClass(id)
 {
 	return new TileClassPainter(getTileClass(id));
 }
 
 /**
  * Create a painter for the given class
  */
 function unPaintClass(id)
 {
 	return new TileClassUnPainter(getTileClass(id));
 }
 
 /**
  * Create an avoid constraint for the given classes by the given distances
  */
 function avoidClasses(/*class1, dist1, class2, dist2, etc*/)
 {
 	let ar = [];
 	for (let i = 0; i < arguments.length/2; ++i)
 		ar.push(new AvoidTileClassConstraint(arguments[2*i], arguments[2*i+1]));
 
 	// Return single constraint
 	if (ar.length == 1)
 		return ar[0];
 
 	return new AndConstraint(ar);
 }
 
 /**
  * Create a stay constraint for the given classes by the given distances
  */
 function stayClasses(/*class1, dist1, class2, dist2, etc*/)
 {
 	let ar = [];
 	for (let i = 0; i < arguments.length/2; ++i)
 		ar.push(new StayInTileClassConstraint(arguments[2*i], arguments[2*i+1]));
 
 	// Return single constraint
 	if (ar.length == 1)
 		return ar[0];
 
 	return new AndConstraint(ar);
 }
 
 /**
  * Create a border constraint for the given classes by the given distances
  */
 function borderClasses(/*class1, idist1, odist1, class2, idist2, odist2, etc*/)
 {
 	let ar = [];
 	for (let i = 0; i < arguments.length/3; ++i)
 		ar.push(new BorderTileClassConstraint(arguments[3*i], arguments[3*i+1], arguments[3*i+2]));
 
 	// Return single constraint
 	if (ar.length == 1)
 		return ar[0];
 
 	return new AndConstraint(ar);
 }
 
 /**
  * Checks if the given tile is in class "id"
  */
 function checkIfInClass(x, z, id)
 {
 	let tileClass = getTileClass(id);
 	if (tileClass === null)
 		return 0;
 
 	let members = tileClass.countMembersInRadius(x, z, 1);
 	if (members === null)
 		return 0;
 
 	return members;
 }
 
 /**
  * Returns the distance between 2 points
  */
 function getDistance(x1, z1, x2, z2)
 {
 	return Math.pow(Math.pow(x1 - x2, 2) + Math.pow(z1 - z2, 2), 1/2);
 }
 
 /**
  * Returns the angle of the vector between point 1 and point 2.
  * The angle is counterclockwise from the positive x axis.
  */
 function getAngle(x1, z1, x2, z2)
 {
 	return Math.atan2(z2 - z1, x2 - x1);
 }
 
 /**
  * Returns the gradient of the line between point 1 and 2 in the form dz/dx
  */
 function getGradient(x1, z1, x2, z2)
 {
 	if (x1 == x2 && z1 == z2)
 		return 0;
 
 	return (z1-z2)/(x1-x2);
 }
 
 function getTerrainTexture(x, y)
 {
 	return g_Map.getTexture(x, y);
 }
 
 /**
  * Returns the order to go through the points for the shortest closed path (array of indices)
  * @param {array} [points] - Points to be sorted of the form { "x": x_value, "y": y_value }
  */
 function getOrderOfPointsForShortestClosePath(points)
 {
 	let order = [];
 	let distances = [];
 	if (points.length <= 3)
 	{
 		for (let i = 0; i < points.length; ++i)
 			order.push(i);
 
 		return order;
 	}
 
 	// Just add the first 3 points
 	let pointsToAdd = clone(points);
 	for (let i = 0; i < 3; ++i)
 	{
 		order.push(i);
 		pointsToAdd.shift(i);
 		if (i)
 			distances.push(getDistance(points[order[i]].x, points[order[i]].y, points[order[i - 1]].x, points[order[i - 1]].y));
 	}
 
 	distances.push(getDistance(
 		points[order[0]].x,
 		points[order[0]].y,
 		points[order[order.length - 1]].x,
 		points[order[order.length - 1]].y));
 
 	// Add remaining points so the path lengthens the least
 	let numPointsToAdd = pointsToAdd.length;
 	for (let i = 0; i < numPointsToAdd; ++i)
 	{
 		let indexToAddTo;
 		let minEnlengthen = Infinity;
 		let minDist1 = 0;
 		let minDist2 = 0;
 		for (let k = 0; k < order.length; ++k)
 		{
 			let dist1 = getDistance(pointsToAdd[0].x, pointsToAdd[0].y, points[order[k]].x, points[order[k]].y);
 			let dist2 = getDistance(pointsToAdd[0].x, pointsToAdd[0].y, points[order[(k + 1) % order.length]].x, points[order[(k + 1) % order.length]].y);
 			let enlengthen = dist1 + dist2 - distances[k];
 			if (enlengthen < minEnlengthen)
 			{
 				indexToAddTo = k;
 				minEnlengthen = enlengthen;
 				minDist1 = dist1;
 				minDist2 = dist2;
 			}
 		}
 		order.splice(indexToAddTo + 1, 0, i + 3);
 		distances.splice(indexToAddTo, 1, minDist1, minDist2);
 		pointsToAdd.shift();
 	}
 
 	return order;
 }
Index: ps/trunk/binaries/data/mods/public/maps/random/sahel.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/sahel.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/sahel.js	(revision 20149)
@@ -1,327 +1,314 @@
 RMS.LoadLibrary("rmgen");
 
 const tGrass1 = "savanna_grass_a";
 const tGrass2 = "savanna_grass_b";
 const tGrass3 = "savanna_shrubs_a";
 const tDirt1 = "savanna_dirt_rocks_a";
 const tDirt2 = "savanna_dirt_rocks_b";
 const tDirt3 = "savanna_dirt_rocks_c";
 const tDirt4 = "savanna_dirt_b";
 const tCityTiles = "savanna_tile_a";
 const tShore = "savanna_riparian_bank";
 const tWater = "savanna_riparian_wet";
 
 const oBaobab = "gaia/flora_tree_baobab";
 const oBerryBush = "gaia/flora_bush_berry";
 const oGazelle = "gaia/fauna_gazelle";
 const oGiraffe = "gaia/fauna_giraffe";
 const oGiraffeInfant = "gaia/fauna_giraffe_infant";
 const oElephant = "gaia/fauna_elephant_african_bush";
 const oElephantInfant = "gaia/fauna_elephant_african_infant";
 const oLion = "gaia/fauna_lion";
 const oLioness = "gaia/fauna_lioness";
 const oZebra = "gaia/fauna_zebra";
 const oStoneSmall = "gaia/geology_stone_savanna_small";
 const oMetalLarge = "gaia/geology_metal_savanna_slabs";
 
 const aBush = "actor|props/flora/bush_medit_sm_dry.xml";
 const aRock = "actor|geology/stone_savanna_med.xml";
 
 InitMap();
 
 var numPlayers = getNumPlayers();
 var mapSize = getMapSize();
 var mapArea = mapSize*mapSize;
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clSettlement = createTileClass();
 
-var playerIDs = sortAllPlayers();
-
-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 [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 	var cliffRadius = 2;
 	var elevation = 20;
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 	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);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oBerryBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = 13;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	createStoneMineFormation(mX, mZ, tDirt4);
 	addToClass(mX, mZ, clPlayer);
 	// create the city patch
 	var cityRadius = radius/3;
 	var placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new TerrainPainter(tCityTiles);
 	createArea(placer, painter, null);
 
 	var hillSize = PI * radius * radius;
 	// create starting trees
 	var num = floor(hillSize / 300);
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(11, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oBaobab, num, num, 2,7)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 
 }
 
 RMS.SetProgress(20);
 
 log("Creating big patches...");
 var patches = [tGrass2, tGrass3];
 for (var i = 0; i < patches.length; i++)
 {
 	placer = new ChainPlacer(floor(scaleByMapSize(3, 6)), floor(scaleByMapSize(10, 20)), floor(scaleByMapSize(15, 60)), 1);
 	painter = new TerrainPainter(patches[i]);
 	createAreas(
 		placer,
 		painter,
 		avoidClasses(clPlayer, 10),
 		scaleByMapSize(5, 20)
 	);
 }
 
 log("Creating small patches...");
 var patches = [tDirt1, tDirt2, tDirt3];
 var sizes = [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)];
 for (var i = 0; i < sizes.length; i++)
 {
 	for (var j = 0; j < patches.length; ++j)
 	{
 		placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 1);
 		painter = new TerrainPainter(patches[j]);
 		createAreas(
 			placer,
 			painter,
 			avoidClasses(clPlayer, 12),
 			scaleByMapSize(4, 15)
 		);
 	}
 }
 
 log("Creating water holes...");
 placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), floor(scaleByMapSize(20, 60)), 1);
 var terrainPainter = new LayeredPainter(
 	[tShore, tWater],		// terrains
 	[1]							// widths
 );
 var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -5, 7);
 createAreas(
 	placer,
 	[terrainPainter, elevationPainter, paintClass(clWater)],
 	avoidClasses(clPlayer, 24),
 	scaleByMapSize(1, 3)
 );
 
 RMS.SetProgress(55);
 
 var playerConstraint = new AvoidTileClassConstraint(clPlayer, 30);
 var minesConstraint = new AvoidTileClassConstraint(clRock, 25);
 var waterConstraint = new AvoidTileClassConstraint(clWater, 10);
 
 log("Creating stone mines...");
 for (var i = 0; i < scaleByMapSize(12,30); ++i)
 {
 	var mX = randIntExclusive(0, mapSize);
 	var mZ = randIntExclusive(0, mapSize);
 	if (playerConstraint.allows(mX, mZ) && minesConstraint.allows(mX, mZ) && waterConstraint.allows(mX, mZ))
 	{
 		createStoneMineFormation(mX, mZ, tDirt4);
 		addToClass(mX, mZ, clRock);
 	}
 }
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clPlayer, 20, clMetal, 10, clRock, 8, clWater, 4),
 	scaleByMapSize(2,8), 100
 );
 
 RMS.SetProgress(65);
 
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRock, 1,3, 0,3)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clPlayer, 7, clWater, 1),
 	scaleByMapSize(200, 1200), 1
 );
 
 RMS.SetProgress(70);
 
 log("Creating gazelle...");
 group = new SimpleGroup(
 	[new SimpleObject(oGazelle, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 1, clPlayer, 20, clFood, 11),
 	scaleByMapSize(4,12), 50
 );
 
 log("Creating zebra...");
 group = new SimpleGroup(
 	[new SimpleObject(oZebra, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 1, clPlayer, 20, clFood, 11),
 	scaleByMapSize(4,12), 50
 );
 
 log("Creating giraffe...");
 group = new SimpleGroup(
 	[new SimpleObject(oGiraffe, 2,4, 0,4), new SimpleObject(oGiraffeInfant, 0,2, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 1, clPlayer, 20, clFood, 11),
 	scaleByMapSize(4,12), 50
 );
 
 log("Creating elephants...");
 group = new SimpleGroup(
 	[new SimpleObject(oElephant, 2,4, 0,4), new SimpleObject(oElephantInfant, 0,2, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 1, clPlayer, 20, clFood, 11),
 	scaleByMapSize(4,12), 50
 );
 
 log("Creating lions...");
 group = new SimpleGroup(
 	[new SimpleObject(oLion, 0,1, 0,4), new SimpleObject(oLioness, 2,3, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 1, clPlayer, 20, clFood, 11),
 	scaleByMapSize(4,12), 50
 );
 
 log("Creating berry bush...");
 group = new SimpleGroup(
 	[new SimpleObject(oBerryBush, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clPlayer, 20, clFood, 12, clRock, 7, clMetal, 6),
 	randIntInclusive(1, 4) * numPlayers + 2, 50
 );
 
 RMS.SetProgress(85);
 
 log("Creating straggler trees...");
 var num = scaleByMapSize(70, 500);
 group = new SimpleGroup(
 	[new SimpleObject(oBaobab, 1,1, 0,3)],
 	true, clForest
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 1, clPlayer, 20, clMetal, 6, clRock, 7, clWater, 1),
 	num
 );
 
 log("Creating large grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aBush, 2,4, 0,1.8, -PI/8,PI/8)]
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clWater, 3, clPlayer, 2, clForest, 0),
 	scaleByMapSize(100, 1200)
 );
 
 setSunColor(0.87451, 0.847059, 0.647059);
 setWaterColor(0.741176, 0.592157, 0.27451);
 setWaterTint(0.741176, 0.592157, 0.27451);
 setWaterWaviness(2.0);
 setWaterType("clap");
 setWaterMurkiness(0.835938);
 
 setUnitsAmbientColor(0.57, 0.58, 0.55);
 setTerrainAmbientColor(0.447059, 0.509804, 0.54902);
 
 setFogFactor(0.25);
 setFogThickness(0.15);
 setFogColor(0.847059, 0.737255, 0.482353);
 
 setPPEffect("hdr");
 setPPContrast(0.57031);
 setPPBloom(0.34);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/snowflake_searocks.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/snowflake_searocks.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/snowflake_searocks.js	(revision 20149)
@@ -1,1819 +1,1807 @@
 RMS.LoadLibrary("rmgen");
 RMS.LoadLibrary("rmbiome");
 
 setSelectedBiome();
 
 const tMainTerrain = g_Terrains.mainTerrain;
 const tForestFloor1 = g_Terrains.forestFloor1;
 const tForestFloor2 = g_Terrains.forestFloor2;
 const tCliff = g_Terrains.cliff;
 const tTier1Terrain = g_Terrains.tier1Terrain;
 const tTier2Terrain = g_Terrains.tier2Terrain;
 const tTier3Terrain = g_Terrains.tier3Terrain;
 const tHill = g_Terrains.mainTerrain;
 const tDirt = g_Terrains.dirt;
 const tRoad = g_Terrains.road;
 const tRoadWild = g_Terrains.roadWild;
 const tTier4Terrain = g_Terrains.tier4Terrain;
 const tShoreBlend = g_Terrains.shoreBlend;
 const tShore = g_Terrains.shore;
 const tWater = g_Terrains.water;
 
 const oTree1 = g_Gaia.tree1;
 const oTree2 = g_Gaia.tree2;
 const oTree3 = g_Gaia.tree3;
 const oTree4 = g_Gaia.tree4;
 const oTree5 = g_Gaia.tree5;
 const oFruitBush = g_Gaia.fruitBush;
 const oMainHuntableAnimal = g_Gaia.mainHuntableAnimal;
 const oFish = g_Gaia.fish;
 const oSecondaryHuntableAnimal = g_Gaia.secondaryHuntableAnimal;
 const oStoneLarge = g_Gaia.stoneLarge;
 const oStoneSmall = g_Gaia.stoneSmall;
 const oMetalLarge = g_Gaia.metalLarge;
 
 const aGrass = g_Decoratives.grass;
 const aGrassShort = g_Decoratives.grassShort;
 const aReeds = g_Decoratives.reeds;
 const aLillies = g_Decoratives.lillies;
 const aRockLarge = g_Decoratives.rockLarge;
 const aRockMedium = g_Decoratives.rockMedium;
 const aBushMedium = g_Decoratives.bushMedium;
 const aBushSmall = g_Decoratives.bushSmall;
 
 const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
 const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 const mapArea = mapSize*mapSize;
 
 log(mapSize);
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clSettlement = createTileClass();
 var clLand = createTileClass();
 
 initTerrain(tWater);
 
 const radius = scaleByMapSize(15,30);
 const cliffRadius = 2;
 const elevation = 20;
 
-var playerIDs = sortAllPlayers();
-
-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 [playerIDs, playerX, playerZ, playerAngle, startAngle] = radialPlayerPlacement();
 
 // Creating other islands
 var numIslands = 0;
 //****************************
 //----------------------------
 //Tiny and Small Size
 //----------------------------
 //****************************
 if ((mapSize == 128)||(mapSize == 192)){
 		//2 PLAYERS
 		//-----------------
 		//-----------------
 	if (numPlayers == 2){
 		numIslands = 4*numPlayers+1;
 		var IslandX = new Array(numIslands);
 		var IslandZ = new Array(numIslands);
 		var isConnected = new Array(numIslands);
 		for (var q=0; q <numIslands; q++)
 		{
 			isConnected[q]=new Array(numIslands);
 		}
 		for (var m = 0; m < numIslands; m++){
 			for (var n = 0; n < numIslands; n++){
 				isConnected[m][n] = 0;
 			}
 		}
 		//connections
 		var sX = 0;
 		var sZ = 0;
 		for (var l = 0; l < numPlayers; l++)
 		{
 			isConnected[4*numPlayers][l+2*numPlayers] = 1;
 			sX = sX + playerX[l];
 			sZ = sZ + playerZ[l];
 		}
 
 		var fx = fractionToTiles(sX/numPlayers);
 		var fz = fractionToTiles(sZ/numPlayers);
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[4*numPlayers]=ix;
 		IslandZ[4*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.36);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		//centeral island id numPlayers
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 		isConnected[e+2*numPlayers][e] = 1;
 		if (e+2*numPlayers+1<numIslands-numPlayers-1)
 		{
 			isConnected[e+2*numPlayers][e+2*numPlayers+1] = 1;
 		}
 		else
 		{
 			isConnected[2*numPlayers][e+2*numPlayers] = 1;
 		}
 
 		var fx = fractionToTiles(0.5 + 0.16*cos(startAngle + e*TWO_PI/numPlayers));
 		var fz = fractionToTiles(0.5 + 0.16*sin(startAngle + e*TWO_PI/numPlayers));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+2*numPlayers]=ix;
 		IslandZ[e+2*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.81);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 		//Small Isles
 		isConnected[e+3*numPlayers][e+numPlayers] = 1;
 		var fx = fractionToTiles(0.5 + 0.27*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var fz = fractionToTiles(0.5 + 0.27*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+3*numPlayers]=ix;
 		IslandZ[e+3*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.49);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 			isConnected[e][e+numPlayers] = 1;
 			if (e+1<numPlayers)
 			{
 				isConnected[e + 1][e+numPlayers] = 1;
 			}
 			else
 			{
 				isConnected[0][e+numPlayers] = 1;
 			}
 
 			//second island id 4
 			var fx = fractionToTiles(0.5 + 0.41*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var fz = fractionToTiles(0.5 + 0.41*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var ix = round(fx);
 			var iz = round(fz);
 			IslandX[e+numPlayers]=ix;
 			IslandZ[e+numPlayers]=iz;
 			// calculate size based on the radius
 			var hillSize = PI * radius * radius;
 
 			// create the hill
 			var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 			var terrainPainter = new LayeredPainter(
 				[tCliff, tHill],		// terrains
 				[cliffRadius]		// widths
 			);
 			var elevationPainter = new SmoothElevationPainter(
 				ELEVATION_SET,			// type
 				elevation,				// elevation
 				cliffRadius				// blend radius
 			);
 			createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 	}
 		//3 PLAYERS
 		//-----------------
 		//-----------------
 		if (numPlayers == 3){
 		numIslands = 4*numPlayers+1;
 		var IslandX = new Array(numIslands);
 		var IslandZ = new Array(numIslands);
 		var isConnected = new Array(numIslands);
 		for (var q=0; q <numIslands; q++)
 		{
 			isConnected[q]=new Array(numIslands);
 		}
 		for (var m = 0; m < numIslands; m++){
 			for (var n = 0; n < numIslands; n++){
 				isConnected[m][n] = 0;
 			}
 		}
 		//connections
 		var sX = 0;
 		var sZ = 0;
 		for (var l = 0; l < numPlayers; l++)
 		{
 			isConnected[4*numPlayers][l+2*numPlayers] = 1;
 			sX = sX + playerX[l];
 			sZ = sZ + playerZ[l];
 		}
 
 		var fx = fractionToTiles(sX/numPlayers);
 		var fz = fractionToTiles(sZ/numPlayers);
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[4*numPlayers]=ix;
 		IslandZ[4*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.36);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		//centeral island id numPlayers
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 		isConnected[e+2*numPlayers][e] = 1;
 		if (e+2*numPlayers+1<numIslands-numPlayers-1)
 		{
 			isConnected[e+2*numPlayers][e+2*numPlayers+1] = 1;
 		}
 		else
 		{
 			isConnected[2*numPlayers][e+2*numPlayers] = 1;
 		}
 
 		var fx = fractionToTiles(0.5 + 0.16*cos(startAngle + e*TWO_PI/numPlayers));
 		var fz = fractionToTiles(0.5 + 0.16*sin(startAngle + e*TWO_PI/numPlayers));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+2*numPlayers]=ix;
 		IslandZ[e+2*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.81);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 		//Small Isles
 		isConnected[e+3*numPlayers][e+numPlayers] = 1;
 		var fx = fractionToTiles(0.5 + 0.27*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var fz = fractionToTiles(0.5 + 0.27*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+3*numPlayers]=ix;
 		IslandZ[e+3*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.49);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 			isConnected[e][e+numPlayers] = 1;
 			if (e+1<numPlayers)
 			{
 				isConnected[e + 1][e+numPlayers] = 1;
 			}
 			else
 			{
 				isConnected[0][e+numPlayers] = 1;
 			}
 
 			//second island id 4
 			var fx = fractionToTiles(0.5 + 0.41*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var fz = fractionToTiles(0.5 + 0.41*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var ix = round(fx);
 			var iz = round(fz);
 			IslandX[e+numPlayers]=ix;
 			IslandZ[e+numPlayers]=iz;
 			// calculate size based on the radius
 			var hillSize = PI * radius * radius;
 
 			// create the hill
 			var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 			var terrainPainter = new LayeredPainter(
 				[tCliff, tHill],		// terrains
 				[cliffRadius]		// widths
 			);
 			var elevationPainter = new SmoothElevationPainter(
 				ELEVATION_SET,			// type
 				elevation,				// elevation
 				cliffRadius				// blend radius
 			);
 			createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 	}
 
 		//4 PLAYERS
 		//-----------------
 		//-----------------
 		if (numPlayers == 4){
 		numIslands = 4*numPlayers+1;
 		var IslandX = new Array(numIslands);
 		var IslandZ = new Array(numIslands);
 		var isConnected = new Array(numIslands);
 		for (var q=0; q <numIslands; q++)
 		{
 			isConnected[q]=new Array(numIslands);
 		}
 		for (var m = 0; m < numIslands; m++){
 			for (var n = 0; n < numIslands; n++){
 				isConnected[m][n] = 0;
 			}
 		}
 		//connections
 		var sX = 0;
 		var sZ = 0;
 		for (var l = 0; l < numPlayers; l++)
 		{
 			isConnected[4*numPlayers][l+2*numPlayers] = 1;
 			sX = sX + playerX[l];
 			sZ = sZ + playerZ[l];
 		}
 
 		var fx = fractionToTiles(sX/numPlayers);
 		var fz = fractionToTiles(sZ/numPlayers);
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[4*numPlayers]=ix;
 		IslandZ[4*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.36);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		//centeral island id numPlayers
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 		isConnected[e+2*numPlayers][e] = 1;
 		if (e+2*numPlayers+1<numIslands-numPlayers-1)
 		{
 			isConnected[e+2*numPlayers][e+2*numPlayers+1] = 1;
 		}
 		else
 		{
 			isConnected[2*numPlayers][e+2*numPlayers] = 1;
 		}
 
 		var fx = fractionToTiles(0.5 + 0.16*cos(startAngle + e*TWO_PI/numPlayers));
 		var fz = fractionToTiles(0.5 + 0.16*sin(startAngle + e*TWO_PI/numPlayers));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+2*numPlayers]=ix;
 		IslandZ[e+2*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.81);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 		//Small Isles
 		isConnected[e+3*numPlayers][e+numPlayers] = 1;
 		var fx = fractionToTiles(0.5 + 0.41*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var fz = fractionToTiles(0.5 + 0.41*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+3*numPlayers]=ix;
 		IslandZ[e+3*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.49);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 			isConnected[e][e+numPlayers] = 1;
 			if (e+1<numPlayers)
 			{
 				isConnected[e + 1][e+numPlayers] = 1;
 			}
 			else
 			{
 				isConnected[0][e+numPlayers] = 1;
 			}
 
 			//second island id 4
 			var fx = fractionToTiles(0.5 + 0.27*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var fz = fractionToTiles(0.5 + 0.27*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var ix = round(fx);
 			var iz = round(fz);
 			IslandX[e+numPlayers]=ix;
 			IslandZ[e+numPlayers]=iz;
 			// calculate size based on the radius
 			var hillSize = PI * radius * radius;
 
 			// create the hill
 			var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 			var terrainPainter = new LayeredPainter(
 				[tCliff, tHill],		// terrains
 				[cliffRadius]		// widths
 			);
 			var elevationPainter = new SmoothElevationPainter(
 				ELEVATION_SET,			// type
 				elevation,				// elevation
 				cliffRadius				// blend radius
 			);
 			createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 	}
 
 			//More than 4 PLAYERS
 		//-----------------
 		//-----------------
 		if (numPlayers > 4){
 		numIslands = numPlayers + 1;
 		var IslandX = new Array(numIslands);
 		var IslandZ = new Array(numIslands);
 		var isConnected = new Array(numIslands);
 		for (var q=0; q <numIslands; q++)
 		{
 			isConnected[q]=new Array(numIslands);
 		}
 		for (var m = 0; m < numIslands; m++){
 			for (var n = 0; n < numIslands; n++){
 				isConnected[m][n] = 0;
 			}
 		}
 		//connections
 		var sX = 0;
 		var sZ = 0;
 		for (var l = 0; l < numPlayers; l++)
 		{
 			isConnected[l][numPlayers] = 1;
 			sX = sX + playerX[l];
 			sZ = sZ + playerZ[l];
 		}
 
 		//centeral island id numPlayers
 
 		var fx = fractionToTiles((sX)/numPlayers);
 		var fz = fractionToTiles((sZ)/numPlayers);
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[numPlayers]=ix;
 		IslandZ[numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = PI * radius * radius;
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 	}
 }
 
 //****************************
 //----------------------------
 //Medium Size
 //----------------------------
 //****************************
 if (mapSize == 256){
 		//2,3,4 PLAYERS
 		//-----------------
 		//-----------------
 		if ((numPlayers == 2)||(numPlayers == 3)||(numPlayers == 4)){
 		numIslands = 4*numPlayers+1;
 		var IslandX = new Array(numIslands);
 		var IslandZ = new Array(numIslands);
 		var isConnected = new Array(numIslands);
 		for (var q=0; q <numIslands; q++)
 		{
 			isConnected[q]=new Array(numIslands);
 		}
 		for (var m = 0; m < numIslands; m++){
 			for (var n = 0; n < numIslands; n++){
 				isConnected[m][n] = 0;
 			}
 		}
 		//connections
 		var sX = 0;
 		var sZ = 0;
 		for (var l = 0; l < numPlayers; l++)
 		{
 			isConnected[4*numPlayers][l+2*numPlayers] = 1;
 			sX = sX + playerX[l];
 			sZ = sZ + playerZ[l];
 		}
 
 		var fx = fractionToTiles(sX/numPlayers);
 		var fz = fractionToTiles(sZ/numPlayers);
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[4*numPlayers]=ix;
 		IslandZ[4*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.36);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		//centeral island id numPlayers
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 		isConnected[e+2*numPlayers][e] = 1;
 		if (e+2*numPlayers+1<numIslands-numPlayers-1)
 		{
 			isConnected[e+2*numPlayers][e+2*numPlayers+1] = 1;
 		}
 		else
 		{
 			isConnected[2*numPlayers][e+2*numPlayers] = 1;
 		}
 
 		var fx = fractionToTiles(0.5 + 0.16*cos(startAngle + e*TWO_PI/numPlayers));
 		var fz = fractionToTiles(0.5 + 0.16*sin(startAngle + e*TWO_PI/numPlayers));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+2*numPlayers]=ix;
 		IslandZ[e+2*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.81);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 		//Small Isles
 		isConnected[e+3*numPlayers][e+numPlayers] = 1;
 		var fx = fractionToTiles(0.5 + 0.41*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var fz = fractionToTiles(0.5 + 0.41*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+3*numPlayers]=ix;
 		IslandZ[e+3*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.49);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 			isConnected[e][e+numPlayers] = 1;
 			if (e+1<numPlayers)
 			{
 				isConnected[e + 1][e+numPlayers] = 1;
 			}
 			else
 			{
 				isConnected[0][e+numPlayers] = 1;
 			}
 
 			//second island id 4
 			var fx = fractionToTiles(0.5 + 0.26*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var fz = fractionToTiles(0.5 + 0.26*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var ix = round(fx);
 			var iz = round(fz);
 			IslandX[e+numPlayers]=ix;
 			IslandZ[e+numPlayers]=iz;
 			// calculate size based on the radius
 			var hillSize = PI * radius * radius;
 
 			// create the hill
 			var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 			var terrainPainter = new LayeredPainter(
 				[tCliff, tHill],		// terrains
 				[cliffRadius]		// widths
 			);
 			var elevationPainter = new SmoothElevationPainter(
 				ELEVATION_SET,			// type
 				elevation,				// elevation
 				cliffRadius				// blend radius
 			);
 			createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 	}
 
 			//More than 4 PLAYERS
 		//-----------------
 		//-----------------
 		if (numPlayers > 4){
 		numIslands = 2*numPlayers;
 		var IslandX = new Array(numIslands);
 		var IslandZ = new Array(numIslands);
 		var isConnected = new Array(numIslands);
 		for (var q=0; q <numIslands; q++)
 		{
 			isConnected[q]=new Array(numIslands);
 		}
 		for (var m = 0; m < numIslands; m++){
 			for (var n = 0; n < numIslands; n++){
 				isConnected[m][n] = 0;
 			}
 		}
 		//connections
 		var sX = 0;
 		var sZ = 0;
 
 		//centeral island id numPlayers
 		for (var e = 0; e <numPlayers; e++)
 		{
 		if (e+1<numPlayers)
 		{
 			isConnected[e][e+1] = 1;
 		}
 		else
 		{
 			isConnected[0][e] = 1;
 		}
 		isConnected[e+numPlayers][e] = 1;
 		if (e+numPlayers+1<numIslands)
 		{
 			isConnected[e+numPlayers][e+numPlayers+1] = 1;
 		}
 		else
 		{
 			isConnected[e+numPlayers][numPlayers] = 1;
 		}
 		var fx = fractionToTiles(0.5 + 0.16*cos(startAngle + e*TWO_PI/numPlayers));
 		var fz = fractionToTiles(0.5 + 0.16*sin(startAngle + e*TWO_PI/numPlayers));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+numPlayers]=ix;
 		IslandZ[e+numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.81);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 
 	}
 }
 
 //****************************
 //----------------------------
 //Normal Size
 //----------------------------
 //****************************
 if (mapSize == 320){
 		//2,3,4,5 PLAYERS
 		//-----------------
 		//-----------------
 		if ((numPlayers == 2)||(numPlayers == 3)||(numPlayers == 4)||(numPlayers == 5)){
 		numIslands = 4*numPlayers+1;
 		var IslandX = new Array(numIslands);
 		var IslandZ = new Array(numIslands);
 		var isConnected = new Array(numIslands);
 		for (var q=0; q <numIslands; q++)
 		{
 			isConnected[q]=new Array(numIslands);
 		}
 		for (var m = 0; m < numIslands; m++){
 			for (var n = 0; n < numIslands; n++){
 				isConnected[m][n] = 0;
 			}
 		}
 		//connections
 		var sX = 0;
 		var sZ = 0;
 		for (var l = 0; l < numPlayers; l++)
 		{
 			isConnected[4*numPlayers][l+2*numPlayers] = 1;
 			sX = sX + playerX[l];
 			sZ = sZ + playerZ[l];
 		}
 
 		var fx = fractionToTiles(sX/numPlayers);
 		var fz = fractionToTiles(sZ/numPlayers);
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[4*numPlayers]=ix;
 		IslandZ[4*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.36);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		//centeral island id numPlayers
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 		isConnected[e+2*numPlayers][e] = 1;
 		if (e+2*numPlayers+1<numIslands-numPlayers-1)
 		{
 			isConnected[e+2*numPlayers][e+2*numPlayers+1] = 1;
 		}
 		else
 		{
 			isConnected[2*numPlayers][e+2*numPlayers] = 1;
 		}
 
 		var fx = fractionToTiles(0.5 + 0.16*cos(startAngle + e*TWO_PI/numPlayers));
 		var fz = fractionToTiles(0.5 + 0.16*sin(startAngle + e*TWO_PI/numPlayers));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+2*numPlayers]=ix;
 		IslandZ[e+2*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.81);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 		//Small Isles
 		isConnected[e+3*numPlayers][e+numPlayers] = 1;
 		var fx = fractionToTiles(0.5 + 0.41*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var fz = fractionToTiles(0.5 + 0.41*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+3*numPlayers]=ix;
 		IslandZ[e+3*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.49);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 			isConnected[e][e+numPlayers] = 1;
 			if (e+1<numPlayers)
 			{
 				isConnected[e + 1][e+numPlayers] = 1;
 			}
 			else
 			{
 				isConnected[0][e+numPlayers] = 1;
 			}
 
 			//second island id 4
 			var fx = fractionToTiles(0.5 + 0.26*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var fz = fractionToTiles(0.5 + 0.26*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var ix = round(fx);
 			var iz = round(fz);
 			IslandX[e+numPlayers]=ix;
 			IslandZ[e+numPlayers]=iz;
 			// calculate size based on the radius
 			var hillSize = PI * radius * radius;
 
 			// create the hill
 			var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 			var terrainPainter = new LayeredPainter(
 				[tCliff, tHill],		// terrains
 				[cliffRadius]		// widths
 			);
 			var elevationPainter = new SmoothElevationPainter(
 				ELEVATION_SET,			// type
 				elevation,				// elevation
 				cliffRadius				// blend radius
 			);
 			createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 	}
 
 		//6,7 PLAYERS
 		//-----------------
 		//-----------------
 		if ((numPlayers == 6)||(numPlayers == 7)){
 		numIslands = 4*numPlayers+1;
 		var IslandX = new Array(numIslands);
 		var IslandZ = new Array(numIslands);
 		var isConnected = new Array(numIslands);
 		for (var q=0; q <numIslands; q++)
 		{
 			isConnected[q]=new Array(numIslands);
 		}
 		for (var m = 0; m < numIslands; m++){
 			for (var n = 0; n < numIslands; n++){
 				isConnected[m][n] = 0;
 			}
 		}
 		//connections
 		var sX = 0;
 		var sZ = 0;
 		for (var l = 0; l < numPlayers; l++)
 		{
 			isConnected[4*numPlayers][l+2*numPlayers] = 1;
 			sX = sX + playerX[l];
 			sZ = sZ + playerZ[l];
 		}
 
 		var fx = fractionToTiles(sX/numPlayers);
 		var fz = fractionToTiles(sZ/numPlayers);
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[4*numPlayers]=ix;
 		IslandZ[4*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.36);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		//centeral island id numPlayers
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 		isConnected[e+2*numPlayers][e] = 1;
 		if (e+2*numPlayers+1<numIslands-numPlayers-1)
 		{
 			isConnected[e+2*numPlayers][e+2*numPlayers+1] = 1;
 		}
 		else
 		{
 			isConnected[2*numPlayers][e+2*numPlayers] = 1;
 		}
 
 		var fx = fractionToTiles(0.5 + 0.16*cos(startAngle + e*TWO_PI/numPlayers));
 		var fz = fractionToTiles(0.5 + 0.16*sin(startAngle + e*TWO_PI/numPlayers));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+2*numPlayers]=ix;
 		IslandZ[e+2*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.81);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 		//Small Isles
 		isConnected[e+3*numPlayers][e+numPlayers] = 1;
 		var fx = fractionToTiles(0.5 + 0.41*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var fz = fractionToTiles(0.5 + 0.41*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+3*numPlayers]=ix;
 		IslandZ[e+3*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.49);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 			isConnected[e][e+numPlayers] = 1;
 			if (e+1<numPlayers)
 			{
 				isConnected[e + 1][e+numPlayers] = 1;
 			}
 			else
 			{
 				isConnected[0][e+numPlayers] = 1;
 			}
 
 			//second island id 4
 			var fx = fractionToTiles(0.5 + 0.26*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var fz = fractionToTiles(0.5 + 0.26*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var ix = round(fx);
 			var iz = round(fz);
 			IslandX[e+numPlayers]=ix;
 			IslandZ[e+numPlayers]=iz;
 			// calculate size based on the radius
 			var hillSize = PI * radius * radius;
 
 			// create the hill
 			var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 			var terrainPainter = new LayeredPainter(
 				[tCliff, tHill],		// terrains
 				[cliffRadius]		// widths
 			);
 			var elevationPainter = new SmoothElevationPainter(
 				ELEVATION_SET,			// type
 				elevation,				// elevation
 				cliffRadius				// blend radius
 			);
 			createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 	}
 		//8 PLAYERS
 		//-----------------
 		//-----------------
 		if (numPlayers == 8){
 		numIslands = 2*numPlayers;
 		var IslandX = new Array(numIslands);
 		var IslandZ = new Array(numIslands);
 		var isConnected = new Array(numIslands);
 		for (var q=0; q <numIslands; q++)
 		{
 			isConnected[q]=new Array(numIslands);
 		}
 		for (var m = 0; m < numIslands; m++){
 			for (var n = 0; n < numIslands; n++){
 				isConnected[m][n] = 0;
 			}
 		}
 		//connections
 		var sX = 0;
 		var sZ = 0;
 
 		//centeral island id numPlayers
 		for (var e = 0; e <numPlayers; e++)
 		{
 		if (e+1<numPlayers)
 		{
 			isConnected[e][e+1] = 1;
 		}
 		else
 		{
 			isConnected[0][e] = 1;
 		}
 		isConnected[e+numPlayers][e] = 1;
 		if (e+numPlayers+1<numIslands)
 		{
 			isConnected[e+numPlayers][e+numPlayers+1] = 1;
 		}
 		else
 		{
 			isConnected[e+numPlayers][numPlayers] = 1;
 		}
 		var fx = fractionToTiles(0.5 + 0.16*cos(startAngle + e*TWO_PI/numPlayers));
 		var fz = fractionToTiles(0.5 + 0.16*sin(startAngle + e*TWO_PI/numPlayers));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+numPlayers]=ix;
 		IslandZ[e+numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.81);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 
 	}
 }
 
 //****************************
 //----------------------------
 //Large and larger Sizes
 //----------------------------
 //****************************
 if (mapSize > 383){
 		//2,3,4,5 PLAYERS
 		//-----------------
 		//-----------------
 		if ((numPlayers == 2)||(numPlayers == 3)||(numPlayers == 4)||(numPlayers == 5)){
 		numIslands = 4*numPlayers+1;
 		var IslandX = new Array(numIslands);
 		var IslandZ = new Array(numIslands);
 		var isConnected = new Array(numIslands);
 		for (var q=0; q <numIslands; q++)
 		{
 			isConnected[q]=new Array(numIslands);
 		}
 		for (var m = 0; m < numIslands; m++){
 			for (var n = 0; n < numIslands; n++){
 				isConnected[m][n] = 0;
 			}
 		}
 		//connections
 		var sX = 0;
 		var sZ = 0;
 		for (var l = 0; l < numPlayers; l++)
 		{
 			isConnected[4*numPlayers][l+2*numPlayers] = 1;
 			sX = sX + playerX[l];
 			sZ = sZ + playerZ[l];
 		}
 
 		var fx = fractionToTiles(sX/numPlayers);
 		var fz = fractionToTiles(sZ/numPlayers);
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[4*numPlayers]=ix;
 		IslandZ[4*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.36);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		//centeral island id numPlayers
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 		isConnected[e+2*numPlayers][e] = 1;
 		if (e+2*numPlayers+1<numIslands-numPlayers-1)
 		{
 			isConnected[e+2*numPlayers][e+2*numPlayers+1] = 1;
 		}
 		else
 		{
 			isConnected[2*numPlayers][e+2*numPlayers] = 1;
 		}
 
 		var fx = fractionToTiles(0.5 + 0.16*cos(startAngle + e*TWO_PI/numPlayers));
 		var fz = fractionToTiles(0.5 + 0.16*sin(startAngle + e*TWO_PI/numPlayers));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+2*numPlayers]=ix;
 		IslandZ[e+2*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.81);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 		//Small Isles
 		isConnected[e+3*numPlayers][e+numPlayers] = 1;
 		var fx = fractionToTiles(0.5 + 0.41*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var fz = fractionToTiles(0.5 + 0.41*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+3*numPlayers]=ix;
 		IslandZ[e+3*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.49);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 			isConnected[e][e+numPlayers] = 1;
 			if (e+1<numPlayers)
 			{
 				isConnected[e + 1][e+numPlayers] = 1;
 			}
 			else
 			{
 				isConnected[0][e+numPlayers] = 1;
 			}
 
 			//second island id 4
 			var fx = fractionToTiles(0.5 + 0.24*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var fz = fractionToTiles(0.5 + 0.24*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var ix = round(fx);
 			var iz = round(fz);
 			IslandX[e+numPlayers]=ix;
 			IslandZ[e+numPlayers]=iz;
 			// calculate size based on the radius
 			var hillSize = PI * radius * radius;
 
 			// create the hill
 			var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 			var terrainPainter = new LayeredPainter(
 				[tCliff, tHill],		// terrains
 				[cliffRadius]		// widths
 			);
 			var elevationPainter = new SmoothElevationPainter(
 				ELEVATION_SET,			// type
 				elevation,				// elevation
 				cliffRadius				// blend radius
 			);
 			createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 
 	}
 
 		//6,7,8 PLAYERS
 		//-----------------
 		//-----------------
 		if ((numPlayers == 6)||(numPlayers == 7)||(numPlayers == 8)){
 		numIslands = 4*numPlayers+1;
 		var IslandX = new Array(numIslands);
 		var IslandZ = new Array(numIslands);
 		var isConnected = new Array(numIslands);
 		for (var q=0; q <numIslands; q++)
 		{
 			isConnected[q]=new Array(numIslands);
 		}
 		for (var m = 0; m < numIslands; m++){
 			for (var n = 0; n < numIslands; n++){
 				isConnected[m][n] = 0;
 			}
 		}
 		//connections
 		var sX = 0;
 		var sZ = 0;
 		for (var l = 0; l < numPlayers; l++)
 		{
 			isConnected[4*numPlayers][l+2*numPlayers] = 1;
 			sX = sX + playerX[l];
 			sZ = sZ + playerZ[l];
 		}
 
 		var fx = fractionToTiles(sX/numPlayers);
 		var fz = fractionToTiles(sZ/numPlayers);
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[4*numPlayers]=ix;
 		IslandZ[4*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.36);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 		//centeral island id numPlayers
 		for (var e = 0; e <numPlayers; e++)
 		{
 		isConnected[e+2*numPlayers][e] = 1;
 		if (e+2*numPlayers+1<numIslands-numPlayers-1)
 		{
 			isConnected[e+2*numPlayers][e+2*numPlayers+1] = 1;
 		}
 		else
 		{
 			isConnected[2*numPlayers][e+2*numPlayers] = 1;
 		}
 
 		var fx = fractionToTiles(0.5 + 0.16*cos(startAngle + e*TWO_PI/numPlayers));
 		var fz = fractionToTiles(0.5 + 0.16*sin(startAngle + e*TWO_PI/numPlayers));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+2*numPlayers]=ix;
 		IslandZ[e+2*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.81);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 
 		//Small Isles
 		isConnected[e+3*numPlayers][e+numPlayers] = 1;
 		var fx = fractionToTiles(0.5 + 0.41*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var fz = fractionToTiles(0.5 + 0.41*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 		var ix = round(fx);
 		var iz = round(fz);
 		IslandX[e+3*numPlayers]=ix;
 		IslandZ[e+3*numPlayers]=iz;
 		// calculate size based on the radius
 		var hillSize = floor(PI * radius * radius * 0.36);
 
 		// create the hill
 		var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 		var terrainPainter = new LayeredPainter(
 			[tCliff, tHill],		// terrains
 			[cliffRadius]		// widths
 		);
 		var elevationPainter = new SmoothElevationPainter(
 			ELEVATION_SET,			// type
 			elevation,				// elevation
 			cliffRadius				// blend radius
 		);
 		createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 
 		for (var e = 0; e <numPlayers; e++)
 		{
 			isConnected[e][e+numPlayers] = 1;
 			if (e+1<numPlayers)
 			{
 				isConnected[e + 1][e+numPlayers] = 1;
 			}
 			else
 			{
 				isConnected[0][e+numPlayers] = 1;
 			}
 
 			//second island id 4
 			var fx = fractionToTiles(0.5 + 0.28*cos(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var fz = fractionToTiles(0.5 + 0.28*sin(startAngle + e*TWO_PI/numPlayers + TWO_PI/(2*numPlayers)));
 			var ix = round(fx);
 			var iz = round(fz);
 			IslandX[e+numPlayers]=ix;
 			IslandZ[e+numPlayers]=iz;
 			// calculate size based on the radius
 			var hillSize = PI * radius * radius * 0.81;
 
 			// create the hill
 			var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 			var terrainPainter = new LayeredPainter(
 				[tCliff, tHill],		// terrains
 				[cliffRadius]		// widths
 			);
 			var elevationPainter = new SmoothElevationPainter(
 				ELEVATION_SET,			// type
 				elevation,				// elevation
 				cliffRadius				// blend radius
 			);
 			createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 		}
 
 	}
 }
 
 for (var m = 0; m < numIslands; m++){
 	for (var n = 0; n < numIslands; n++){
 		if(isConnected[m][n] == 1){
 			isConnected[n][m] = 1;
 		}
 	}
 }
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 		IslandX[i]=ix;
 		IslandZ[i]=iz;
 	// calculate size based on the radius
 	var hillSize = PI * radius * radius;
 
 	// create the hill
 	var placer = new ClumpPlacer(hillSize, 0.95, 0.6, 10, ix, iz);
 	var terrainPainter = new LayeredPainter(
 		[tCliff, tHill],		// terrains
 		[cliffRadius]		// widths
 	);
 	var elevationPainter = new SmoothElevationPainter(
 		ELEVATION_SET,			// type
 		elevation,				// elevation
 		cliffRadius				// blend radius
 	);
 	createArea(placer, [terrainPainter, elevationPainter, paintClass(clPlayer)], null);
 
 	// create the city patch
 	var cityRadius = radius/3;
 	placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tRoadWild, tRoad], [1]);
 	createArea(placer, painter, null);
 
 	placeCivDefaultEntities(fx, fz, id, { 'iberWall': 'towers' });
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 10;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oFruitBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 		mAngle = randFloat(0, TWO_PI);
 
 	var mDist = radius - 4;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var num = floor(hillSize / 60);
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = 11;
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oTree1, num, num, 0,4)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, [avoidClasses(clBaseResource,2), stayClasses(clPlayer, 3)]);
 
 	placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 }
 
 RMS.SetProgress(30);
 
 //Create connectors
 for (var ix = 0; ix < mapSize; ix++)
 	for (var iz = 0; iz < mapSize; iz++)
 		for (var m = 0; m < numIslands; m++)
 			for (var n = 0; n < numIslands; n++)
 				if(isConnected[m][n] == 1)
 				{
 					var a = IslandZ[m]-IslandZ[n];
 					var b = IslandX[n]-IslandX[m];
 					var c = (IslandZ[m]*(IslandX[m]-IslandX[n]))-(IslandX[m]*(IslandZ[m]-IslandZ[n]));
 					var dis = abs(a*ix + b*iz + c)/sqrt(a*a + b*b);
 					var k = (a*ix + b*iz + c)/(a*a + b*b);
 					var y = iz-(b*k);
 					if((dis < 5)&&(y <= Math.max(IslandZ[m],IslandZ[n]))&&(y >= Math.min(IslandZ[m],IslandZ[n])))
 					{
 						if (dis < 3)
 						{
 							var h = 20;
 							if (dis < 2)
 								var t = tHill;
 							else
 								var t = tCliff;
 							addToClass(ix, iz, clLand);
 						}
 						else
 						{
 							var h = 50 - 10 * dis;
 							var t = tCliff;
 							addToClass(ix, iz, clLand);
 						}
 
 						if (getHeight(ix, iz)<h)
 						{
 							placeTerrain(ix, iz, t);
 							setHeight(ix, iz, h);
 						}
 					}
 				}
 
 // calculate desired number of trees for map (based on size)
 if (currentBiome() == "savanna")
 {
 	var MIN_TREES = 200;
 	var MAX_TREES = 1250;
 	var P_FOREST = 0.02;
 }
 else if (currentBiome() == "tropic")
 {
 	var MIN_TREES = 1000;
 	var MAX_TREES = 6000;
 	var P_FOREST = 0.6;
 }
 else
 {
 	var MIN_TREES = 500;
 	var MAX_TREES = 3000;
 	var P_FOREST = 0.7;
 }
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 var numForest = totalTrees * P_FOREST;
 var numStragglers = totalTrees * (1.0 - P_FOREST);
 
 log("Creating forests...");
 var types = [
 	[[tForestFloor2, tMainTerrain, pForest1], [tForestFloor2, pForest1]],
 	[[tForestFloor1, tMainTerrain, pForest2], [tForestFloor1, pForest2]]
 ];	// some variation
 
 if (currentBiome() == "savanna")
 	var size = numForest / (0.5 * scaleByMapSize(2,8) * numPlayers);
 else
 	var size = numForest / (scaleByMapSize(2,8) * numPlayers);
 
 var 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...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 10, clRock, 10, clHill, 1), stayClasses(clLand, 5)],
 	5*scaleByMapSize(4,16), 100
 );
 
 log("Creating small stone quarries...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 10, clRock, 10, clHill, 1), stayClasses(clLand, 5)],
 	5*scaleByMapSize(4,16), 100
 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 10, clMetal, 10, clRock, 5, clHill, 1), stayClasses(clLand, 5)],
 	5*scaleByMapSize(4,16), 100
 );
 
 RMS.SetProgress(65);
 log("Creating dirt patches...");
 var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
 for (var i = 0; i < sizes.length; i++)
 {
 	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
 	painter = new LayeredPainter(
 		[[tMainTerrain,tTier1Terrain],[tTier1Terrain,tTier2Terrain], [tTier2Terrain,tTier3Terrain]], 		// terrains
 		[1,1]															// widths
 	);
 	createAreas(
 		placer,
 		[painter, paintClass(clDirt)],
 		[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12), stayClasses(clLand, 5)],
 		scaleByMapSize(15, 45)
 	);
 }
 
 log("Creating grass patches...");
 var sizes = [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)];
 for (var i = 0; i < sizes.length; i++)
 {
 	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
 	painter = new TerrainPainter(tTier4Terrain);
 	createAreas(
 		placer,
 		painter,
 		[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12), stayClasses(clLand, 5)],
 		scaleByMapSize(15, 45)
 	);
 }
 
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockMedium, 1,3, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 4)],
 	scaleByMapSize(16, 262), 50
 );
 
 log("Creating large decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 4)],
 	scaleByMapSize(8, 131), 50
 );
 
 RMS.SetProgress(70);
 
 log("Creating deer...");
 group = new SimpleGroup(
 	[new SimpleObject(oMainHuntableAnimal, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 10, clHill, 1, clFood, 20), stayClasses(clLand, 4)],
 	3 * numPlayers, 50
 );
 
 RMS.SetProgress(75);
 
 log("Creating sheep...");
 group = new SimpleGroup(
 	[new SimpleObject(oSecondaryHuntableAnimal, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 10, clHill, 1, clFood, 20), stayClasses(clLand, 4)],
 	3 * numPlayers, 50
 );
 
 log("Creating fruits...");
 group = new SimpleGroup(
 	[new SimpleObject(oFruitBush, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 0, clPlayer, 10, clHill, 1, clFood, 20), stayClasses(clLand, 4)],
 	3 * numPlayers, 50
 );
 RMS.SetProgress(85);
 
 log("Creating straggler trees...");
 var types = [oTree1, oTree2, oTree4, oTree3];	// some variation
 var num = floor(numStragglers / types.length);
 for (var i = 0; i < types.length; ++i)
 {
 	group = new SimpleGroup(
 		[new SimpleObject(types[i], 1,1, 0,3)],
 		true, clForest
 	);
 	createObjectGroupsDeprecated(group, 0,
 		[avoidClasses(clForest, 1, clHill, 1, clPlayer, 9, clMetal, 6, clRock, 6), stayClasses(clLand, 4)],
 		num
 	);
 }
 
 var planetm = 1;
 if (currentBiome() == "tropic")
 	planetm = 8;
 
 log("Creating small grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)]
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clHill, 2, clPlayer, 2, clDirt, 0), stayClasses(clLand, 4)],
 	planetm * scaleByMapSize(13, 200)
 );
 
 RMS.SetProgress(90);
 
 log("Creating large grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aGrass, 2,4, 0,1.8, -PI/8,PI/8), new SimpleObject(aGrassShort, 3,6, 1.2,2.5, -PI/8,PI/8)]
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clHill, 2, clPlayer, 2, clDirt, 1, clForest, 0), stayClasses(clLand, 4)],
 	planetm * scaleByMapSize(13, 200)
 );
 RMS.SetProgress(95);
 
 log("Creating bushes...");
 group = new SimpleGroup(
 	[new SimpleObject(aBushMedium, 1,2, 0,2), new SimpleObject(aBushSmall, 2,4, 0,2)]
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clHill, 1, clPlayer, 1, clDirt, 1), stayClasses(clLand, 4)],
 	planetm * scaleByMapSize(13, 200), 50
 );
 
 setSkySet(pickRandom(["cirrus", "cumulus", "sunny"]));
 setSunRotation(randFloat(0, TWO_PI));
 setSunElevation(randFloat(PI/ 5, PI / 3));
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/syria.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/syria.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/syria.js	(revision 20149)
@@ -1,377 +1,365 @@
 RMS.LoadLibrary("rmgen");
 
 //terrain textures
 const tMainDirt = ["desert_dirt_rocks_1", "desert_dirt_cracks"];
 const tForestFloor1 = "forestfloor_dirty";
 const tForestFloor2 = "desert_forestfloor_palms";
 const tGrassSands = "desert_grass_a_sand";
 const tGrass = "desert_grass_a";
 const tSecondaryDirt = "medit_dirt_dry";
 const tCliff = ["desert_cliff_persia_1", "desert_cliff_persia_2"];
 const tHill = ["desert_dirt_rocks_1", "desert_dirt_rocks_2", "desert_dirt_rocks_3"];
 const tDirt = ["desert_dirt_rough", "desert_dirt_rough_2"];
 const tRoad = "desert_shore_stones";;
 const tRoadWild = "desert_grass_a_stones";;
 
 const oTamarix = "gaia/flora_tree_tamarix";
 const oPalm = "gaia/flora_tree_date_palm";
 const oPine = "gaia/flora_tree_aleppo_pine";
 const oBush = "gaia/flora_bush_grapes";
 const oCamel = "gaia/fauna_camel";
 const oGazelle = "gaia/fauna_gazelle";
 const oLion = "gaia/fauna_lion";
 const oLioness = "gaia/fauna_lioness";
 const oStoneLarge = "gaia/geology_stonemine_desert_quarry";
 const oStoneSmall = "gaia/geology_stone_desert_small";
 const oMetalLarge = "gaia/geology_metal_desert_slabs";
 
 const aFlower1 = "actor|props/flora/decals_flowers_daisies.xml";
 const aWaterFlower = "actor|props/flora/water_lillies.xml";
 const aReedsA = "actor|props/flora/reeds_pond_lush_a.xml";
 const aReedsB = "actor|props/flora/reeds_pond_lush_b.xml";
 const aRock = "actor|geology/stone_desert_med.xml";
 const aBushA = "actor|props/flora/bush_desert_dry_a.xml";
 const aBushB = "actor|props/flora/bush_desert_dry_a.xml";
 const aBushes = [aBushA, aBushB];
 const aSand = "actor|particle/blowing_sand.xml";
 
 const pForestP = [tForestFloor2 + TERRAIN_SEPARATOR + oPalm, tForestFloor2];
 const pForestT = [tForestFloor1 + TERRAIN_SEPARATOR + oTamarix,tForestFloor2];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 const mapArea = mapSize*mapSize;
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clSettlement = createTileClass();
 var clGrass = createTileClass();
 
-var playerIDs = sortAllPlayers();
-
-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 [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	// scale radius of player area by map size
 	var radius = scaleByMapSize(15,25);
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 
 	// calculate size based on the radius
 	var size = PI * radius * radius;
 
 	// create the player area
 	var placer = new ClumpPlacer(size, 0.9, 0.5, 10, ix, iz);
 	createArea(placer, paintClass(clPlayer), null);
 
 	// create the grass patches
 	var grassRadius = floor(scaleByMapSize(16 ,30));
 	placer = new ChainPlacer(2, floor(scaleByMapSize(5, 12)), floor(scaleByMapSize(25, 60)), 1, ix, iz, 0, [grassRadius]);
 	var painter = new LayeredPainter([tGrassSands, tGrass], [3]);
 	createArea(placer, [painter, paintClass(clGrass)], null);
 
 	// create the city patch
 	var cityRadius = 10;
 	placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 	var painter = new LayeredPainter([tRoadWild, tRoad], [3]);
 	createArea(placer, painter, null);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	placeDefaultChicken(fx, fz, clBaseResource);
 
 	// create berry bushes
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var bbX = round(fx + bbDist * cos(bbAngle));
 	var bbZ = round(fz + bbDist * sin(bbAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oBush, 5,5, 0,3)],
 		true, clBaseResource, bbX, bbZ
 	);
 	createObjectGroup(group, 0);
 
 	// create metal mine
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 	{
 		mAngle = randFloat(0, TWO_PI);
 	}
 	var mDist = 11;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0), new RandomObject(aBushes, 2,4, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2), new RandomObject(aBushes, 2,4, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var num = 3;
 	var tAngle = randFloat(-PI/3, 4*PI/3);
 	var tDist = randFloat(11, 13);
 	var tX = round(fx + tDist * cos(tAngle));
 	var tZ = round(fz + tDist * sin(tAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(pickRandom([oPalm, oTamarix]), num, num, 0,5)],
 		false, clBaseResource, tX, tZ
 	);
 	createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 }
 
 RMS.SetProgress(10);
 
 log("Creating bumps...");
 placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1);
 painter = new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2);
 createAreas(
 	placer,
 	painter,
 	avoidClasses(clPlayer, 13),
 	scaleByMapSize(300, 800)
 );
 
 log("Creating hills...");
 placer = new ChainPlacer(1, floor(scaleByMapSize(4, 6)), floor(scaleByMapSize(16, 40)), 0.5);
 var terrainPainter = new LayeredPainter(
 	[tCliff, tHill],		// terrains
 	[2]								// widths
 );
 var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 22, 2);
 createAreas(
 	placer,
 	[terrainPainter, elevationPainter, paintClass(clHill)],
 	avoidClasses(clPlayer, 3, clGrass, 1, clHill, 10),
 	scaleByMapSize(1, 3) * numPlayers * 3
 );
 
 RMS.SetProgress(25);
 
 // calculate desired number of trees for map (based on size)
 const MIN_TREES = 400;
 const MAX_TREES = 2000;
 const P_FOREST = 0.7;
 
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 var numForest = totalTrees * P_FOREST;
 var numStragglers = totalTrees * (1.0 - P_FOREST);
 
 log("Creating forests...");
 var types = [
 	[[tMainDirt, tForestFloor2, pForestP], [tForestFloor2, pForestP]],
 	[[tMainDirt, tForestFloor1, pForestT], [tForestFloor1, pForestT]]
 ];	// some variation
 var size = numForest / (scaleByMapSize(3,6) * numPlayers);
 var num = floor(size / types.length);
 for (var i = 0; i < types.length; ++i)
 {
 	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), numForest / (num * floor(scaleByMapSize(2,4))), 0.5);
 	painter = new LayeredPainter(
 		types[i],		// terrains
 		[2]											// widths
 		);
 	createAreas(
 		placer,
 		[painter, paintClass(clForest)],
 		avoidClasses(clPlayer, 1, clGrass, 1, clForest, 10, clHill, 1),
 		num
 	);
 }
 
 RMS.SetProgress(40);
 
 log("Creating dirt patches...");
 var sizes = [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)];
 for (var i = 0; i < sizes.length; i++)
 {
 	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
 	painter = new LayeredPainter(
 		[tSecondaryDirt ,tDirt], 		// terrains
 		[1]															// widths
 	);
 	createAreas(
 		placer,
 		painter,
 		avoidClasses(clHill, 0, clForest, 0, clPlayer, 8, clGrass, 1),
 		scaleByMapSize(50, 90)
 	);
 }
 RMS.SetProgress(60);
 
 log("Creating big patches...");
 var sizes = [scaleByMapSize(6, 30), scaleByMapSize(10, 50), scaleByMapSize(16, 70)];
 for (var i = 0; i < sizes.length; i++)
 {
 	placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
 	painter = new LayeredPainter(
 		[tSecondaryDirt ,tDirt], 		// terrains
 		[1]															// widths
 	);
 	createAreas(
 		placer,
 		painter,
 		avoidClasses(clHill, 0, clForest, 0, clPlayer, 8, clGrass, 1),
 		scaleByMapSize(30, 90)
 	);
 }
 RMS.SetProgress(70);
 
 log("Creating stone mines...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4), new RandomObject(aBushes, 2,4, 0,2)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 10, clRock, 10, clHill, 1, clGrass, 1)],
 	scaleByMapSize(2,8), 100
 );
 
 log("Creating small stone quarries...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3), new RandomObject(aBushes, 2,4, 0,2)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 10, clRock, 10, clHill, 1, clGrass, 1)],
 	scaleByMapSize(2,8), 100
 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4), new RandomObject(aBushes, 2,4, 0,2)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 10, clMetal, 10, clRock, 5, clHill, 1, clGrass, 1)],
 	scaleByMapSize(2,8), 100
 );
 
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRock, 1,3, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clForest, 0, clPlayer, 0, clHill, 0),
 	scaleByMapSize(16, 262), 50
 );
 
 log("Creating bushes...");
 group = new SimpleGroup(
 	[new SimpleObject(aBushB, 1,2, 0,1), new SimpleObject(aBushA, 1,3, 0,2)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clForest, 0, clPlayer, 0, clHill, 0),
 	scaleByMapSize(50, 500), 50
 );
 RMS.SetProgress(80);
 
 log("Creating gazelle...");
 group = new SimpleGroup(
 	[new SimpleObject(oGazelle, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 1, clHill, 1, clFood, 20, clGrass, 2),
 	3 * numPlayers, 50
 );
 
 log("Creating lions...");
 group = new SimpleGroup(
 	[new SimpleObject(oLion, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 1, clHill, 1, clFood, 20, clGrass, 2),
 	3 * numPlayers, 50
 );
 
 log("Creating camels...");
 group = new SimpleGroup(
 	[new SimpleObject(oCamel, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 0, clPlayer, 1, clHill, 1, clFood, 20, clGrass, 2),
 	3 * numPlayers, 50
 );
 RMS.SetProgress(85);
 
 log("Creating straggler trees...");
 var types = [oPalm, oTamarix, oPine];	// some variation
 var num = floor(numStragglers / types.length);
 for (var i = 0; i < types.length; ++i)
 {
 	group = new SimpleGroup(
 		[new SimpleObject(types[i], 1,1, 0,3)],
 		true, clForest
 	);
 	createObjectGroupsDeprecated(group, 0,
 		avoidClasses(clForest, 1, clHill, 1, clPlayer, 1, clMetal, 6, clRock, 6),
 		num
 	);
 }
 
 log("Creating straggler trees...");
 var types = [oPalm, oTamarix, 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
 	);
 	createObjectGroupsDeprecated(group, 0,
 		[avoidClasses(clForest, 1, clHill, 1, clPlayer, 1, clMetal, 6, clRock, 6), stayClasses(clGrass, 3)],
 		num
 	);
 }
 
 setSkySet("sunny");
 setSunElevation(PI / 8);
 setSunRotation(randFloat(0, TWO_PI));
 setSunColor(0.746, 0.718, 0.539);
 setWaterColor(0.292, 0.347, 0.691);
 setWaterTint(0.550, 0.543, 0.437);
 setWaterMurkiness(0.83);
 
 setFogColor(0.8, 0.76, 0.61);
 setFogThickness(0.2);
 setFogFactor(0.4);
 
 setPPEffect("hdr");
 setPPContrast(0.65);
 setPPSaturation(0.42);
 setPPBloom(0.6);
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/volcanic_lands.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/volcanic_lands.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/volcanic_lands.js	(revision 20149)
@@ -1,285 +1,272 @@
 RMS.LoadLibrary("rmgen");
 
 var tGrass = ["cliff volcanic light", "ocean_rock_a", "ocean_rock_b"];
 var tGrassA = "cliff volcanic light";
 var tGrassB = "ocean_rock_a";
 var tGrassC = "ocean_rock_b";
 var tCliff = ["cliff volcanic coarse", "cave_walls"];
 var tRoad = "road1";
 var tRoadWild = "road1";
 var tLava1 = "LavaTest05";
 var tLava2 = "LavaTest04";
 var tLava3 = "LavaTest03";
 
 var oTree = "gaia/flora_tree_dead";
 var oStoneLarge = "gaia/geology_stonemine_alpine_quarry";
 var oStoneSmall = "gaia/geology_stone_alpine_a";
 var oMetalLarge = "gaia/geology_metal_alpine_slabs";
 
 var aRockLarge = "actor|geology/stone_granite_med.xml";
 var aRockMedium = "actor|geology/stone_granite_med.xml";
 
 var pForestD = [tGrassC + TERRAIN_SEPARATOR + oTree, tGrassC];
 var pForestP = [tGrassB + TERRAIN_SEPARATOR + oTree, tGrassB];
 
 InitMap();
 
 var numPlayers = getNumPlayers();
 var mapSize = getMapSize();
 var mapArea = mapSize*mapSize;
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clBaseResource = createTileClass();
 
-var playerIDs = sortAllPlayers();
-
-// 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 [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 for (var i = 0; i < numPlayers; i++)
 {
 	var id = playerIDs[i];
 	log("Creating base for player " + id + "...");
 
 	var radius = scaleByMapSize(15,25);
 
 	// get the x and z in tiles
 	var fx = fractionToTiles(playerX[i]);
 	var fz = fractionToTiles(playerZ[i]);
 	var ix = round(fx);
 	var iz = round(fz);
 	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);
 
 	placeCivDefaultEntities(fx, fz, id);
 
 	// create metal mine
 	var bbAngle = randFloat(0, TWO_PI);
 	var bbDist = 12;
 	var mAngle = bbAngle;
 	while(abs(mAngle - bbAngle) < PI/3)
 		mAngle = randFloat(0, TWO_PI);
 
 	var mDist = 12;
 	var mX = round(fx + mDist * cos(mAngle));
 	var mZ = round(fz + mDist * sin(mAngle));
 	var group = new SimpleGroup(
 		[new SimpleObject(oMetalLarge, 1,1, 0,0)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create stone mines
 	mAngle += randFloat(PI/8, PI/4);
 	mX = round(fx + mDist * cos(mAngle));
 	mZ = round(fz + mDist * sin(mAngle));
 	group = new SimpleGroup(
 		[new SimpleObject(oStoneLarge, 1,1, 0,2)],
 		true, clBaseResource, mX, mZ
 	);
 	createObjectGroup(group, 0);
 
 	// create starting trees
 	var hillSize = PI * radius * radius;
 	var num = floor(hillSize / 60);
 	var tries = 10;
 	for (var x = 0; x < tries; ++x)
 	{
 		var tAngle = randFloat(-PI/3, 4*PI/3);
 		var tDist = randFloat(12, 13);
 		var tX = round(fx + tDist * cos(tAngle));
 		var tZ = round(fz + tDist * sin(tAngle));
 		group = new SimpleGroup(
 			[new SimpleObject(oTree, num, num, 0, 3)],
 			false, clBaseResource, tX, tZ
 		);
 		if (createObjectGroup(group, 0, avoidClasses(clBaseResource, 2)))
 			break;
 	}
 }
 RMS.SetProgress(15);
 
 createVolcano(0.5, 0.5, clHill, tCliff, [tLava1, tLava2, tLava3], true, ELEVATION_SET);
 RMS.SetProgress(45);
 
 log("Creating hills...");
 createAreas(
 	new ClumpPlacer(scaleByMapSize(20, 150), 0.2, 0.1, 1),
 	[
 		new LayeredPainter([tCliff, tGrass], [2]),
 		new SmoothElevationPainter(ELEVATION_SET, 18, 2),
 		paintClass(clHill)
 	],
 	avoidClasses(clPlayer, 12, clHill, 15, clBaseResource, 2),
 	scaleByMapSize(2, 8) * numPlayers
 );
 
 // calculate desired number of trees for map (based on size)
 var MIN_TREES = 200;
 var MAX_TREES = 1250;
 var P_FOREST = 0.7;
 
 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 var numForest = totalTrees * P_FOREST;
 var numStragglers = totalTrees * (1.0 - P_FOREST);
 
 log("Creating forests...");
 var types = [
 	[[tGrassB, tGrassA, pForestD], [tGrassB, pForestD]],
 	[[tGrassB, tGrassA, pForestP], [tGrassB, pForestP]]
 ];	// some variation
 
 var size = numForest / (scaleByMapSize(2,8) * numPlayers);
 
 var num = floor(size / types.length);
 for (var i = 0; i < types.length; ++i)
 {
 	placer = new ClumpPlacer(numForest / num, 0.1, 0.1, 1);
 	painter = new LayeredPainter(
 		types[i],		// terrains
 		[2]											// widths
 		);
 	createAreas(
 		placer,
 		[painter, paintClass(clForest)],
 		avoidClasses(clPlayer, 12, clForest, 10, clHill, 0),
 		num
 	);
 }
 
 RMS.SetProgress(70);
 
 log("Creating dirt patches...");
 var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
 for (var i = 0; i < sizes.length; i++)
 {
 	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
 	painter = new LayeredPainter(
 		[tGrassA,tGrassA], 		// terrains
 		[1]															// widths
 	);
 	createAreas(
 		placer,
 		[painter, paintClass(clDirt)],
 		avoidClasses(clForest, 0, clHill, 0, clPlayer, 12),
 		scaleByMapSize(20, 80)
 	);
 }
 var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
 for (var i = 0; i < sizes.length; i++)
 {
 	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
 	painter = new LayeredPainter(
 		[tGrassB,tGrassB], 		// terrains
 		[1]															// widths
 	);
 	createAreas(
 		placer,
 		[painter, paintClass(clDirt)],
 		avoidClasses(clForest, 0, clHill, 0, clPlayer, 12),
 		scaleByMapSize(20, 80)
 	);
 }
 var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
 for (var i = 0; i < sizes.length; i++)
 {
 	placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
 	painter = new LayeredPainter(
 		[tGrassC,tGrassC], 		// terrains
 		[1]															// widths
 	);
 	createAreas(
 		placer,
 		[painter, paintClass(clDirt)],
 		avoidClasses(clForest, 0, clHill, 0, clPlayer, 12),
 		scaleByMapSize(20, 80)
 	);
 }
 
 log("Creating stone mines...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 1, clPlayer, 10, clRock, 10, clHill, 1),
 	scaleByMapSize(4,16), 100
 );
 
 log("Creating small stone mines...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 1, clPlayer, 10, clRock, 10, clHill, 1),
 	scaleByMapSize(4,16), 100
 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clForest, 1, clPlayer, 10, clMetal, 10, clRock, 5, clHill, 1),
 	scaleByMapSize(4,16), 100
 );
 
 RMS.SetProgress(90);
 
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockMedium, 1,3, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clForest, 0, clPlayer, 0, clHill, 0),
 	scaleByMapSize(16, 262), 50
 );
 
 log("Creating large decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	avoidClasses(clForest, 0, clPlayer, 0, clHill, 0),
 	scaleByMapSize(8, 131), 50
 );
 
 RMS.SetProgress(95);
 
 log("Creating straggler trees...");
 var types = [oTree];	// some variation
 var num = floor(numStragglers / types.length);
 for (var i = 0; i < types.length; ++i)
 {
 	group = new SimpleGroup(
 		[new SimpleObject(types[i], 1,1, 0,3)],
 		true, clForest
 	);
 	createObjectGroupsDeprecated(group, 0,
 		avoidClasses(clForest, 1, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6),
 		num
 	);
 }
 
 ExportMap();
Index: ps/trunk/binaries/data/mods/public/maps/random/unknown.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/unknown.js	(revision 20148)
+++ ps/trunk/binaries/data/mods/public/maps/random/unknown.js	(revision 20149)
@@ -1,1873 +1,1795 @@
 RMS.LoadLibrary("rmgen");
 RMS.LoadLibrary("rmbiome");
 
 TILE_CENTERED_HEIGHT_MAP = true;
 
 setSelectedBiome();
 
 const tMainTerrain = g_Terrains.mainTerrain;
 const tForestFloor1 = g_Terrains.forestFloor1;
 const tForestFloor2 = g_Terrains.forestFloor2;
 const tCliff = g_Terrains.cliff;
 const tTier1Terrain = g_Terrains.tier1Terrain;
 const tTier2Terrain = g_Terrains.tier2Terrain;
 const tTier3Terrain = g_Terrains.tier3Terrain;
 const tHill = g_Terrains.hill;
 const tDirt = g_Terrains.dirt;
 const tRoad = g_Terrains.road;
 const tRoadWild = g_Terrains.roadWild;
 const tTier4Terrain = g_Terrains.tier4Terrain;
 const tShoreBlend = g_Terrains.shoreBlend;
 const tShore = g_Terrains.shore;
 const tWater = g_Terrains.water;
 
 const oTree1 = g_Gaia.tree1;
 const oTree2 = g_Gaia.tree2;
 const oTree3 = g_Gaia.tree3;
 const oTree4 = g_Gaia.tree4;
 const oTree5 = g_Gaia.tree5;
 const oFruitBush = g_Gaia.fruitBush;
 const oMainHuntableAnimal = g_Gaia.mainHuntableAnimal;
 const oFish = g_Gaia.fish;
 const oSecondaryHuntableAnimal = g_Gaia.secondaryHuntableAnimal;
 const oStoneLarge = g_Gaia.stoneLarge;
 const oStoneSmall = g_Gaia.stoneSmall;
 const oMetalLarge = g_Gaia.metalLarge;
 const oWood = "gaia/special_treasure_wood";
 
 const aGrass = g_Decoratives.grass;
 const aGrassShort = g_Decoratives.grassShort;
 const aReeds = g_Decoratives.reeds;
 const aLillies = g_Decoratives.lillies;
 const aRockLarge = g_Decoratives.rockLarge;
 const aRockMedium = g_Decoratives.rockMedium;
 const aBushMedium = g_Decoratives.bushMedium;
 const aBushSmall = g_Decoratives.bushSmall;
 
 const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
 const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
 
 InitMap();
 
 const numPlayers = getNumPlayers();
 const mapSize = getMapSize();
 const mapArea = mapSize*mapSize;
 
 var clPlayer = createTileClass();
 var clHill = createTileClass();
 var clForest = createTileClass();
 var clWater = createTileClass();
 var clDirt = createTileClass();
 var clRock = createTileClass();
 var clMetal = createTileClass();
 var clFood = createTileClass();
 var clBaseResource = createTileClass();
 var clSettlement = createTileClass();
 var clLand = createTileClass();
 var clShallow = createTileClass();
 
 initTerrain(tWater);
 
 var iberianTowers = false;
 var md = randIntInclusive(1,13);
 var needsAdditionalWood = false;
 //*****************************************************************************************************************************
 if (md == 1) //archipelago and island
 {
 	needsAdditionalWood = true;
 	iberianTowers = true;
 
-	var playerIDs = sortAllPlayers();
-
-	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 [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
 	var mdd1 = randIntInclusive(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
 	{
 		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)*randIntInclusive(8,14)
 		);
 
 		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
 	{
 		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)*randIntInclusive(8,14)
 		);
 
 		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)*randIntInclusive(6,15), 25
 		);
 	}
 	else if (mdd1 == 3) // tight 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, randIntInclusive(8, 16), clPlayer, 3),
 			scaleByMapSize(2, 5)*randIntInclusive(8,14)
 		);
 	}
 
 }
 //********************************************************************************************************
 else if (md == 2) //continent
 {
-	var playerIDs = sortAllPlayers();
+	var [playerIDs, playerX, playerZ] = radialPlayerPlacement(0.25);
 
-	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 (randBool(1/3)) // 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);
 	}
 
 	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
 	);
 
 	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
 {
 	var playerIDs = primeSortAllPlayers();
 
 	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 = randIntInclusive(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 (randBool(1/3))
 	{
 		// linked
 		if (mdd1 == 1) //vertical
 		{
 			var placer = new PathPlacer(1, fractionToTiles(0.5), fractionToTiles(0.99), fractionToTiles(0.5), scaleByMapSize(randIntInclusive(16,24),randIntInclusive(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(randIntInclusive(16,24),randIntInclusive(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 = randIntInclusive(1,7);
 	if (mdd2 == 1)
 	{
 		log("Creating islands...");
 		placer = new ClumpPlacer(randIntInclusive(scaleByMapSize(8,15),scaleByMapSize(15,23))*randIntInclusive(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)*randIntInclusive(8,14)
 		);
 	}
 	else if (mdd2 == 2)
 	{
 		log("Creating extentions...");
 		placer = new ClumpPlacer(randIntInclusive(scaleByMapSize(13,24),scaleByMapSize(24,45))*randIntInclusive(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)*randIntInclusive(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);
 		}
 	}
 
 	var playerIDs = primeSortAllPlayers();
 
 	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 = randIntInclusive(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);
 		}
 	}
 
 	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 = randIntInclusive(1,2);
 	if (mdd2 == 1)
 	{
 		log("Creating the shallows of the main river");
 
 		for (var i = 0; i <= randIntInclusive(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 (randBool())
 	{
 		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);
 		}
 
 		log("Creating tributaries");
 
 		for (var i = 0; i <= randIntInclusive(8, (scaleByMapSize(12,20))); i++)
 		{
 			var cLocation = randFloat(0.05,0.95);
 			var tang = randFloat(PI*0.2, PI*0.8)*((randIntInclusive(0, 1)-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
 {
-	var playerIDs = sortAllPlayers();
+	var [playerIDs, playerX, playerZ] = radialPlayerPlacement();
 
-	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 = randIntInclusive(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);
 
 		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 (randBool()) // 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 (randBool(1/3) &&(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 = randIntInclusive(1,2);
 
 	var playerIDs = sortAllPlayers();
 
 	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 = randIntInclusive(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);
 						}
 					}
 				}
 			}
 		}
 	}
 
 	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 = randIntInclusive(1,3);
 	if (mdd3 == 1)
 	{
 		log("Creating islands...");
 		placer = new ClumpPlacer(randIntInclusive(scaleByMapSize(8,15),scaleByMapSize(15,23))*randIntInclusive(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)*randIntInclusive(8,14)
 		);
 	}
 	else if (mdd3 == 2)
 	{
 		log("Creating extentions...");
 		placer = new ClumpPlacer(randIntInclusive(scaleByMapSize(13,24),scaleByMapSize(24,45))*randIntInclusive(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)*randIntInclusive(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);
 
 	var playerIDs = sortAllPlayers();
 
 	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
 {
-	var playerIDs = sortAllPlayers();
-
-	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 [playerIDs, playerX, playerZ, playerAngle] = radialPlayerPlacement();
 
 	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);
 	}
 
 	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 (randBool())
 	{
 		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
 {
-	var playerIDs = sortAllPlayers();
-
-	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 [playerIDs, playerX, playerZ, playerAngle] = radialPlayerPlacement();
 
 	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);
 		}
 	}
 
 	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 = randIntInclusive(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
 {
-	var playerIDs = sortAllPlayers();
-
-	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 [playerIDs, playerX, playerZ, playerAngle] = radialPlayerPlacement();
 
 	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
 {
-	var playerIDs = sortAllPlayers();
-
-	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 [playerIDs, playerX, playerZ, playerAngle] = radialPlayerPlacement();
 
 	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 + "...");
 
 	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);
 
 	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);
 }
 
 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)],
 	randIntInclusive(0,scaleByMapSize(200, 400))
 );
 
 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, randIntInclusive(6, 18)), stayClasses(clLand, 0)],
 	randIntInclusive(0, scaleByMapSize(4, 8))*randIntInclusive(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 (currentBiome() == "savanna")
 {
 	var MIN_TREES = floor(200*multiplier);
 	var MAX_TREES = floor(1250*multiplier);
 	var P_FOREST = randFloat(0.02, 0.05);
 }
 else if (currentBiome() == "tropic")
 {
 	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);
 
 log("Creating forests...");
 var types = [
 	[[tForestFloor2, tMainTerrain, pForest1], [tForestFloor2, pForest1]],
 	[[tForestFloor1, tMainTerrain, pForest2], [tForestFloor1, pForest2]]
 ];	// some variation
 
 if (currentBiome() == "savanna")
 	var size = numForest / (0.5 * scaleByMapSize(2,8) * numPlayers);
 else
 	var size = numForest / (scaleByMapSize(2,8) * numPlayers);
 
 var 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, randIntInclusive(5, 15), clHill, 0), stayClasses(clLand, 4)],
 		num
 	);
 }
 
 RMS.SetProgress(50);
 
 log("Creating dirt patches...");
 var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
 var numb = 1;
 if (currentBiome() == "savanna")
 	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)
 	);
 }
 
 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...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 20, clRock, 10, clHill, 1), stayClasses(clLand, 4)],
 	randIntInclusive(scaleByMapSize(2,9),scaleByMapSize(9,40)), 100
 );
 
 log("Creating small stone quarries...");
 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 20, clRock, 10, clHill, 1), stayClasses(clLand, 4)],
 	randIntInclusive(scaleByMapSize(2,9),scaleByMapSize(9,40)), 100
 );
 
 log("Creating metal mines...");
 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clForest, 1, clPlayer, 20, clMetal, 10, clRock, 5, clHill, 1), stayClasses(clLand, 4)],
 	randIntInclusive(scaleByMapSize(2,9),scaleByMapSize(9,40)), 100
 );
 
 RMS.SetProgress(65);
 
 log("Creating small decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockMedium, 1,3, 0,1)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	[avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 4)],
 	scaleByMapSize(16, 262), 50
 );
 
 log("Creating large decorative rocks...");
 group = new SimpleGroup(
 	[new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
 	true
 );
 createObjectGroupsDeprecated(
 	group, 0,
 	[avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 4)],
 	scaleByMapSize(8, 131), 50
 );
 RMS.SetProgress(70);
 
 log("Creating deer...");
 group = new SimpleGroup(
 	[new SimpleObject(oMainHuntableAnimal, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clWater, 0, clForest, 0, clPlayer, 20, clHill, 1, clFood, 20), stayClasses(clLand, 4)],
 	randIntInclusive(numPlayers+3, 5*numPlayers+4), 50
 );
 
 log("Creating berry bush...");
 group = new SimpleGroup(
 	[new SimpleObject(oFruitBush, 5,7, 0,4)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clWater, 0, clForest, 0, clPlayer, 20, clHill, 1, clFood, 20), stayClasses(clLand, 4)],
 	randIntInclusive(1, 4) * numPlayers + 2, 50
 );
 
 RMS.SetProgress(75);
 
 log("Creating sheep...");
 group = new SimpleGroup(
 	[new SimpleObject(oSecondaryHuntableAnimal, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clWater, 0, clForest, 0, clPlayer, 20, clHill, 1, clFood, 20), stayClasses(clLand, 4)],
 	randIntInclusive(numPlayers+3, 5*numPlayers+4), 50
 );
 
 log("Creating fish...");
 group = new SimpleGroup(
 	[new SimpleObject(oFish, 2,3, 0,2)],
 	true, clFood
 );
 createObjectGroupsDeprecated(group, 0,
 	avoidClasses(clLand, 5, clForest, 0, clPlayer, 0, clHill, 0, clFood, 20),
 	randIntInclusive(15, 40) * numPlayers, 60
 );
 
 RMS.SetProgress(85);
 
 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
 	);
 	createObjectGroupsDeprecated(group, 0,
 		[avoidClasses(clWater, 1, clForest, 1, clHill, 1, clPlayer, 0, clMetal, 6, clRock, 6), stayClasses(clLand, 4)],
 		num
 	);
 }
 
 var planetm = 1;
 if (currentBiome() == "tropic")
 	planetm = 8;
 
 log("Creating small grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)]
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clWater, 2, clHill, 2, clPlayer, 2, clDirt, 0), stayClasses(clLand, 4)],
 	planetm * scaleByMapSize(13, 200)
 );
 
 RMS.SetProgress(90);
 
 log("Creating large grass tufts...");
 group = new SimpleGroup(
 	[new SimpleObject(aGrass, 2,4, 0,1.8, -PI/8,PI/8), new SimpleObject(aGrassShort, 3,6, 1.2,2.5, -PI/8,PI/8)]
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clWater, 3, clHill, 2, clPlayer, 2, clDirt, 1, clForest, 0), stayClasses(clLand, 4)],
 	planetm * scaleByMapSize(13, 200)
 );
 RMS.SetProgress(95);
 
 log("Creating shallow flora...");
 group = new SimpleGroup(
 	[new SimpleObject(aLillies, 1,2, 0,2), new SimpleObject(aReeds, 2,4, 0,2)]
 );
 createObjectGroupsDeprecated(group, 0,
 	stayClasses(clShallow, 1),
 	60 * scaleByMapSize(13, 200), 80
 );
 
 log("Creating bushes...");
 group = new SimpleGroup(
 	[new SimpleObject(aBushMedium, 1,2, 0,2), new SimpleObject(aBushSmall, 2,4, 0,2)]
 );
 createObjectGroupsDeprecated(group, 0,
 	[avoidClasses(clWater, 1, clHill, 1, clPlayer, 1, clDirt, 1), stayClasses(clLand, 3)],
 	planetm * scaleByMapSize(13, 200), 50
 );
 
 setSkySet(pickRandom(["cirrus", "cumulus", "sunny", "sunny 1", "mountainous", "stratus"]));
 setSunRotation(randFloat(0, TWO_PI));
 setSunElevation(randFloat(PI/ 5, PI / 3));
 
 ExportMap();