binaries/data/mods/public/maps/random/island_stronghold.js

   1 /**
   2  * Returns starting position in tile coordinates for the given player.
   3  */
   4 function getPlayerTileCoordinates(playerIdx, teamIdx, fractionX, fractionZ)
   5 {
   6         let playerAngle = startAngle + (playerIdx+1) * TWO_PI / teams[teamIdx].length;
   7
   8         let fx = fractionToTiles(fractionX + 0.05 * cos(playerAngle));
   9         let fz = fractionToTiles(fractionZ + 0.05 * sin(playerAngle));
  10
  11         return [playerAngle, fx, fz, round(fx), round(fz)];
  12 }
  13
  14 RMS.LoadLibrary("rmgen");
  15 RMS.LoadLibrary("heightmap");
  16
  17 const g_InitialMines = 1;
  18 const g_InitialMineDistance = 14;
  19 const g_InitialTrees = 50;
  20
  21 let random_terrain = randomizeBiome([g_BiomeSavanna]);
  22
  23 const tMainTerrain = rBiomeT1();
  24 const tForestFloor1 = rBiomeT2();
  25 const tForestFloor2 = rBiomeT3();
  26 const tCliff = rBiomeT4();
  27 const tTier1Terrain = rBiomeT5();
  28 const tTier2Terrain = rBiomeT6();
  29 const tTier3Terrain = rBiomeT7();
  30 const tHill = rBiomeT8();
  31 const tTier4Terrain = rBiomeT12();
  32 const tShore = rBiomeT14();
  33 const tWater = rBiomeT15();
  34
  35 // gaia entities
  36 const oTree1 = rBiomeE1();
  37 const oTree2 = rBiomeE2();
  38 const oTree3 = rBiomeE3();
  39 const oTree4 = rBiomeE4();
  40 const oTree5 = rBiomeE5();
  41 const oFruitBush = rBiomeE6();
  42 const oMainHuntableAnimal = rBiomeE8();
  43 const oFish = rBiomeE9();
  44 const oSecondaryHuntableAnimal = rBiomeE10();
  45 const oStoneLarge = rBiomeE11();
  46 const oStoneSmall = rBiomeE12();
  47 const oMetalLarge = rBiomeE13();
  48 const oWhale = "gaia/fauna_whale_humpback";
  49 const oShipwreck = "other/special_treasure_shipwreck";
  50 const oShipDebris = "other/special_treasure_shipwreck_debris";
  51 const oObelisk = "other/obelisk";
  52
  53 // decorative props
  54 const aGrass = rBiomeA1();
  55 const aGrassShort = rBiomeA2();
  56 const aRockLarge = rBiomeA5();
  57 const aRockMedium = rBiomeA6();
  58
  59 const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
  60 const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
  61
  62 log("Initializing map...");
  63 InitMap();
  64
  65 const numPlayers = getNumPlayers();
  66 const mapSize = getMapSize();
  67
  68 // create tile classes
  69 let clPlayer = createTileClass();
  70 let clHill = createTileClass();
  71 let clForest = createTileClass();
  72 let clDirt = createTileClass();
  73 let clRock = createTileClass();
  74 let clMetal = createTileClass();
  75 let clFood = createTileClass();
  76 let clBaseResource = createTileClass();
  77 let clLand = createTileClass();
  78
  79 for (let ix = 0; ix < mapSize; ++ix)
  80         for (let iz = 0; iz < mapSize; ++iz)
  81                 placeTerrain(ix, iz, tWater);
  82
  83 // some constants
  84 let radius = scaleByMapSize(15, 25);
  85
  86 let fx = fractionToTiles(0.5);
  87 let fz = fractionToTiles(0.5);
  88
  89 let startAngle = randFloat(0, TWO_PI);
  90
  91 // Group players by team
  92 let teams = [];
  93 for (let i = 0; i < numPlayers; ++i)
  94 {
  95         let team = getPlayerTeam(i);
  96         if (team == -1)
  97                 continue;
  98
  99         if (!teams[team])
 100                 teams[team] = [];
 101
 102         teams[team].push(i+1);
 103 }
 104
 105 // Players without a team get a custom index
 106 for (let i = 0; i < numPlayers; ++i)
 107 {
 108         let team = getPlayerTeam(i);
 109         if (team != -1)
 110                 continue;
 111
 112         let unusedIndex = teams.findIndex(team => !team);
 113
 114         if (unusedIndex != -1)
 115                 teams[unusedIndex] = [i+1];
 116         else
 117                 teams.push([i+1]);
 118 }
 119
 120 // Get number of used team IDs
 121 let numTeams = teams.filter(team => team).length;
 122
 123 RMS.SetProgress(10);
 124
 125 let shoreRadius = 6;
 126 let elevation = 3;
 127 let teamNo = 0;
 128
 129 for (let i = 0; i < teams.length; ++i)
 130 {
 131         if (!teams[i])
 132                 continue;
 133
 134         ++teamNo;
 135         let teamAngle = startAngle + teamNo*TWO_PI/numTeams;
 136         let fractionX = 0.5 + 0.3 * cos(teamAngle);
 137         let fractionZ = 0.5 + 0.3 * sin(teamAngle);
 138         let teamX = fractionToTiles(fractionX);
 139         let teamZ = fractionToTiles(fractionZ);
 140
 141         log("Creating island and starting entities for team " + i);
 142         for (let p = 0; p < teams[i].length; ++p)
 143         {
 144                 let [playerAngle, fx, fz, ix, iz] = getPlayerTileCoordinates(p, i, fractionX, fractionZ);
 145
 146                 // mark a small area around the player's starting coordinates with the clPlayer class
 147                 addToClass(ix, iz, clPlayer);
 148                 addToClass(ix+5, iz, clPlayer);
 149                 addToClass(ix, iz+5, clPlayer);
 150                 addToClass(ix-5, iz, clPlayer);
 151                 addToClass(ix, iz-5, clPlayer);
 152
 153                 // create an island
 154                 let placer = new ChainPlacer(2, floor(scaleByMapSize(5, 11)), floor(scaleByMapSize(60, 250)), 1, ix, iz, 0, [floor(mapSize * 0.01)]);
 155                 let terrainPainter = new LayeredPainter(
 156                         [tMainTerrain, tMainTerrain, tMainTerrain],       // terrains
 157                         [1, shoreRadius]     // widths
 158                 );
 159                 let elevationPainter = new SmoothElevationPainter(
 160                         ELEVATION_SET,          // type
 161                         elevation,              // elevation
 162                         shoreRadius               // blend radius
 163                 );
 164                 createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
 165
 166                 // create starting units
 167                 placeCivDefaultEntities(fx, fz, teams[i][p], { "iberWall": false });
 168         }
 169
 170         log("Create initial mines for team " + i);
 171         for (let p = 0; p < teams[i].length; ++p)
 172         {
 173                 let [playerAngle, fx, fz, ix, iz] = getPlayerTileCoordinates(p, i, fractionX, fractionZ);
 174                 let mAngle = randFloat(playerAngle - PI / teams[i].length, playerAngle + PI / teams[i].length);
 175
 176                 // Metal
 177                 let mX = round(fx + g_InitialMineDistance * cos(mAngle));
 178                 let mZ = round(fz + g_InitialMineDistance * sin(mAngle));
 179                 let group = new SimpleGroup(
 180                         [new SimpleObject(oMetalLarge, g_InitialMines, g_InitialMines, 0, 4)],
 181                         true, clBaseResource, mX, mZ
 182                 );
 183                 createObjectGroup(group, 0, [avoidClasses(clBaseResource, 2, clPlayer, 4), stayClasses(clLand, 2)]);
 184
 185                 // Stone
 186                 let sX = round(fx + g_InitialMineDistance * cos(mAngle + PI/4));
 187                 let sZ = round(fz + g_InitialMineDistance * sin(mAngle + PI/4));
 188                 group = new SimpleGroup(
 189                         [new SimpleObject(oStoneLarge, g_InitialMines, g_InitialMines, 0, 4)],
 190                         true, clBaseResource, sX, sZ
 191                 );
 192                 createObjectGroup(group, 0, [avoidClasses(clBaseResource, 2, clPlayer, 4), stayClasses(clLand, 2)]);
 193         }
 194
 195         log("Place initial trees and animals for team " + i);
 196         for (let p = 0; p < teams[i].length; ++p)
 197         {
 198                 let [playerAngle, fx, fz, ix, iz] = getPlayerTileCoordinates(p, i, fractionX, fractionZ);
 199
 200                 placeDefaultChicken(fx, fz, clBaseResource, [stayClasses(clLand, 5)]);
 201
 202                 // create initial berry bushes
 203                 let bbAngle = randFloat(PI, PI*1.5);
 204                 let bbDist = 10;
 205                 let bbX = round(fx + bbDist * cos(bbAngle));
 206                 let bbZ = round(fz + bbDist * sin(bbAngle));
 207                 let group = new SimpleGroup(
 208                         [new SimpleObject(oFruitBush, 5, 5, 0, 3)],
 209                         true, clBaseResource, bbX, bbZ
 210                 );
 211                 createObjectGroup(group, 0, [avoidClasses(clBaseResource, 4, clPlayer, 4), stayClasses(clLand, 5)]);
 212
 213                 // create initial trees
 214                 let tries = 10;
 215                 let tDist = 16;
 216                 for (let x = 0; x < tries; ++x)
 217                 {
 218                         let tAngle = randFloat(playerAngle - TWO_PI/teams[i].length,
 219                                                playerAngle + TWO_PI/teams[i].length);
 220
 221                         let tX = round(fx + tDist * cos(tAngle));
 222                         let tZ = round(fz + tDist * sin(tAngle));
 223
 224                         group = new SimpleGroup(
 225                                 [new SimpleObject(oTree2, g_InitialTrees, g_InitialTrees, 0, 7)],
 226                                 true, clBaseResource, tX, tZ
 227                         );
 228                         if (createObjectGroup(group, 0, [avoidClasses(clBaseResource, 4, clPlayer, 4), stayClasses(clLand, 4)]))
 229                                 break;
 230                 }
 231
 232                 // create huntable animals
 233                 group = new SimpleGroup(
 234                         [new SimpleObject(oMainHuntableAnimal, 2 * numPlayers / numTeams, 2 * numPlayers / numTeams, 0, floor(mapSize * 0.2))],
 235                         true, clBaseResource, teamX, teamZ
 236                 );
 237                 createObjectGroup(group, 0, [avoidClasses(clBaseResource, 2, clHill, 1, clPlayer, 10), stayClasses(clLand, 5)]);
 238                 group = new SimpleGroup(
 239                         [new SimpleObject(oSecondaryHuntableAnimal, 4 * numPlayers / numTeams, 4 * numPlayers / numTeams, 0, floor(mapSize * 0.2))],
 240                         true, clBaseResource, teamX, teamZ
 241                 );
 242                 createObjectGroup(group, 0, [avoidClasses(clBaseResource, 2, clHill, 1, clPlayer, 10), stayClasses(clLand, 5)]);
 243         }
 244 }
 245
 246 RMS.SetProgress(40);
 247
 248 log("Creating expansion islands...");
 249 let landAreas = [];
 250 let playerConstraint = new AvoidTileClassConstraint(clPlayer, floor(scaleByMapSize(12, 16)));
 251 let landConstraint = new AvoidTileClassConstraint(clLand, floor(scaleByMapSize(12, 16)));
 252
 253 for (let x = 0; x < mapSize; ++x)
 254         for (let z = 0; z < mapSize; ++z)
 255                 if (playerConstraint.allows(x, z) && landConstraint.allows(x, z))
 256                         landAreas.push([x, z]);
 257
 258 log("Creating big islands...");
 259 let chosenPoint;
 260 let landAreaLen;
 261 let numIslands = scaleByMapSize(4, 14);
 262 for (let i = 0; i < numIslands; ++i)
 263 {
 264         landAreaLen = landAreas.length;
 265         if (!landAreaLen)
 266                 break;
 267
 268         chosenPoint = landAreas[randInt(landAreaLen)];
 269
 270         // create big islands
 271         let placer = new ChainPlacer(floor(scaleByMapSize(4, 8)), floor(scaleByMapSize(8, 14)), floor(scaleByMapSize(25, 60)), 0.07, chosenPoint[0], chosenPoint[1], scaleByMapSize(30, 70));
 272         let terrainPainter = new LayeredPainter(
 273                 [tMainTerrain, tMainTerrain],           // terrains
 274                 [2]                                                             // widths
 275         );
 276
 277         let elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 6);
 278         let newIsland = createAreas(
 279                 placer,
 280                 [terrainPainter, elevationPainter, paintClass(clLand)],
 281                 avoidClasses(clLand, 3, clPlayer, 3),
 282                 1, 1
 283         );
 284
 285         if (!newIsland || !newIsland.length)
 286                 continue;
 287
 288         let n = 0;
 289         for (let j = 0; j < landAreaLen; ++j)
 290         {
 291                 let x = landAreas[j][0];
 292                 let z = landAreas[j][1];
 293
 294                 if (playerConstraint.allows(x, z) && landConstraint.allows(x, z))
 295                         landAreas[n++] = landAreas[j];
 296         }
 297         landAreas.length = n;
 298 }
 299
 300 playerConstraint = new AvoidTileClassConstraint(clPlayer, floor(scaleByMapSize(9, 12)));
 301 landConstraint = new AvoidTileClassConstraint(clLand, floor(scaleByMapSize(9, 12)));
 302
 303 log("Creating small islands...");
 304 numIslands = scaleByMapSize(6, 18) * scaleByMapSize(1, 3);
 305 for (let i = 0; i < numIslands; ++i)
 306 {
 307         landAreaLen = landAreas.length;
 308         if (!landAreaLen)
 309                 break;
 310
 311         chosenPoint = landAreas[randInt(0, landAreaLen)];
 312
 313         let placer = new ChainPlacer(floor(scaleByMapSize(4, 7)), floor(scaleByMapSize(7, 10)), floor(scaleByMapSize(16, 40)), 0.07, chosenPoint[0], chosenPoint[1], scaleByMapSize(22, 40));
 314         let terrainPainter = new LayeredPainter(
 315                 [tMainTerrain, tMainTerrain],           // terrains
 316                 [2]                                                             // widths
 317         );
 318
 319         let elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 6);
 320         let newIsland = createAreas(
 321                 placer,
 322                 [terrainPainter, elevationPainter, paintClass(clLand)],
 323                 avoidClasses(clLand, 3, clPlayer, 3),
 324                 1, 1
 325         );
 326
 327         if (newIsland === undefined)
 328                 continue;
 329
 330         let temp = [];
 331         for (let j = 0; j < landAreaLen; ++j)
 332         {
 333                 let x = landAreas[j][0];
 334                 let z = landAreas[j][1];
 335
 336                 if (playerConstraint.allows(x, z) && landConstraint.allows(x, z))
 337                         temp.push([x, z]);
 338         }
 339         landAreas = temp;
 340 }
 341
 342 RMS.SetProgress(70);
 343
 344 log("Smoothing heightmap...");
 345 for (let i = 0; i < 5; ++i)
 346         globalSmoothHeightmap();
 347
 348 // repaint clLand to compensate for smoothing
 349 unPaintTileClassBasedOnHeight(-10, 10, 3, clLand);
 350 paintTileClassBasedOnHeight(0, 5, 3, clLand);
 351
 352 RMS.SetProgress(85);
 353
 354 createBumps();
 355
 356 createMines(
 357 [
 358         [new SimpleObject(oMetalLarge, 1, 1, 3, (numPlayers * 2) + 1)]
 359 ],
 360 [avoidClasses(clForest, 1, clPlayer, 40, clRock, 20, clHill, 5), stayClasses(clLand, 4)],
 361 clMetal
 362 );
 363
 364 createMines(
 365 [
 366         [new SimpleObject(oStoneLarge, 1, 1, 3, (numPlayers * 2) + 1)], [new SimpleObject(oStoneSmall, 2, 2, 2, (numPlayers * 2) + 1)]
 367 ],
 368 [avoidClasses(clForest, 1, clPlayer, 40, clMetal, 20, clHill, 5), stayClasses(clLand, 4)],
 369 clRock
 370 );
 371
 372 createForests(
 373  [tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
 374  [avoidClasses(clPlayer, 10, clForest, 20, clHill, 10, clBaseResource, 5, clRock, 4, clMetal, 4), stayClasses(clLand, 3)],
 375  clForest,
 376  1.0,
 377  random_terrain
 378 );
 379
 380 log("Creating hills...");
 381 let placer = new ChainPlacer(1, floor(scaleByMapSize(4, 6)), floor(scaleByMapSize(16, 40)), 0.5);
 382 let painter = new LayeredPainter(
 383         [tCliff, tHill],                // terrains
 384         [2]                                                             // widths
 385 );
 386 let elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 18, 2);
 387 createAreas(
 388         placer,
 389         [painter, elevationPainter, paintClass(clHill)],
 390         [avoidClasses(clBaseResource, 20, clHill, 15, clRock, 4, clMetal, 4), stayClasses(clLand, 0)],
 391         scaleByMapSize(4, 13)
 392 );
 393 for (let i = 0; i < 3; ++i)
 394         globalSmoothHeightmap();
 395
 396 createStragglerTrees(
 397                 [oTree1, oTree2, oTree4, oTree3],
 398                 [avoidClasses(clForest, 10, clPlayer, 20, clMetal, 1, clRock, 1, clHill, 1),
 399                  stayClasses(clLand, 4)]
 400 );
 401
 402 createFood(
 403         [
 404                 [new SimpleObject(oMainHuntableAnimal, 5, 7, 0, 4)],
 405                 [new SimpleObject(oSecondaryHuntableAnimal, 2, 3, 0, 2)]
 406         ],
 407         [3 * numPlayers, 3 * numPlayers],
 408         [avoidClasses(clForest, 0, clPlayer, 20, clHill, 1, clRock, 4, clMetal, 4), stayClasses(clLand, 2)]
 409 );
 410
 411 createFood(
 412         [
 413                 [new SimpleObject(oFruitBush, 5, 7, 0, 4)]
 414         ],
 415         [3 * numPlayers],
 416         [avoidClasses(clForest, 0, clPlayer, 15, clHill, 1, clFood, 4, clRock, 4, clMetal, 4), stayClasses(clLand, 2)]
 417 );
 418
 419 if (random_terrain == g_BiomeDesert)
 420 {
 421         log("Creating obelisks");
 422         let group = new SimpleGroup(
 423                 [new SimpleObject(oObelisk, 1, 1, 0, 1)],
 424                 true
 425         );
 426         createObjectGroups(
 427                 group, 0,
 428                 [avoidClasses(clBaseResource, 0, clHill, 0, clRock, 0, clMetal, 0, clFood, 0), stayClasses(clLand, 1)],
 429                 scaleByMapSize(3, 8), 1000
 430         );
 431 }
 432
 433 log("Creating dirt patches...");
 434 let sizes = [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)];
 435 let numb = random_terrain == g_BiomeSavanna ? 3 : 1;
 436
 437 for (let i = 0; i < sizes.length; ++i)
 438 {
 439         placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
 440         painter = new LayeredPainter(
 441                 [[tMainTerrain,tTier1Terrain], [tTier1Terrain,tTier2Terrain], [tTier2Terrain,tTier3Terrain]],           // terrains
 442                 [1, 1]                                                                                                                  // widths
 443         );
 444         createAreas(
 445                 placer,
 446                 [painter, paintClass(clDirt)],
 447                 [avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 0), stayClasses(clLand, 4)],
 448                 numb*scaleByMapSize(15, 45)
 449         );
 450 }
 451
 452 log("Creating grass patches...");
 453 sizes = [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)];
 454 for (let i = 0; i < sizes.length; ++i)
 455 {
 456         placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
 457         painter = new TerrainPainter(tTier4Terrain);
 458         createAreas(
 459                 placer,
 460                 painter,
 461                 [avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 0), stayClasses(clLand, 4)],
 462                 numb * scaleByMapSize(15, 45)
 463         );
 464 }
 465
 466 log("Creating small decorative rocks...");
 467 let group = new SimpleGroup(
 468         [new SimpleObject(aRockMedium, 1, 3, 0, 1)],
 469         true
 470 );
 471 createObjectGroups(
 472         group, 0,
 473         [avoidClasses(clForest, 0, clHill, 0), stayClasses(clLand, 2)],
 474         scaleByMapSize(16, 262), 50
 475 );
 476
 477 log("Creating large decorative rocks...");
 478 group = new SimpleGroup(
 479         [new SimpleObject(aRockLarge, 1, 2, 0, 1), new SimpleObject(aRockMedium, 1, 3, 0, 2)],
 480         true
 481 );
 482 createObjectGroups(
 483         group, 0,
 484         [avoidClasses(clForest, 0, clHill, 0), stayClasses(clLand, 2)],
 485         scaleByMapSize(8, 131), 50
 486 );
 487
 488 log("Creating fish...");
 489 group = new SimpleGroup(
 490         [new SimpleObject(oFish, 2, 3, 0, 2)],
 491         true, clFood
 492 );
 493 createObjectGroups(group, 0,
 494         avoidClasses(clLand, 4, clFood, 20),
 495         25 * numPlayers, 60
 496 );
 497
 498 log("Creating Whales...");
 499 group = new SimpleGroup(
 500         [new SimpleObject(oWhale, 1, 1, 0, 3)],
 501         true, clFood
 502 );
 503 createObjectGroups(group, 0,
 504         [avoidClasses(clLand, 4),avoidClasses(clFood, 8)],
 505         scaleByMapSize(5, 20), 100
 506 );
 507
 508 log("Creating shipwrecks...");
 509 group = new SimpleGroup(
 510         [new SimpleObject(oShipwreck, 1, 1, 0, 1)],
 511         true, clFood
 512 );
 513 createObjectGroups(group, 0,
 514         [avoidClasses(clLand, 4),avoidClasses(clFood, 8)],
 515         scaleByMapSize(12, 16), 100
 516 );
 517
 518 log("Creating shipwreck debris...");
 519 group = new SimpleGroup(
 520         [new SimpleObject(oShipDebris, 1, 1, 0, 1)],
 521         true, clFood
 522 );
 523 createObjectGroups(group, 0,
 524         [avoidClasses(clLand, 4),avoidClasses(clFood, 8)],
 525         scaleByMapSize(10, 20), 100
 526 );
 527
 528 log("Creating grass tufts...");
 529 let num = (PI * radius * radius) / 250;
 530 for (let j = 0; j < num; ++j)
 531 {
 532         let gAngle = randFloat(0, TWO_PI);
 533         let gDist = radius - (5 + randInt(7));
 534         let gX = round(fx + gDist * cos(gAngle));
 535         let gZ = round(fz + gDist * sin(gAngle));
 536         group = new SimpleGroup(
 537                 [new SimpleObject(aGrassShort, 2, 5, 0, 1, -PI / 8, PI / 8)],
 538                 false, clBaseResource, gX, gZ
 539         );
 540         createObjectGroup(group, 0, [stayClasses(clLand, 5)]);
 541 }
 542
 543 log("Creating small grass tufts...");
 544 let planetm = random_terrain == 7 ? 8 : 1;
 545 group = new SimpleGroup(
 546         [new SimpleObject(aGrassShort, 1, 2, 0, 1, -PI / 8, PI / 8)]
 547 );
 548 createObjectGroups(group, 0,
 549         [avoidClasses(clHill, 2, clPlayer, 2, clDirt, 0), stayClasses(clLand, 3)],
 550         planetm * scaleByMapSize(13, 200)
 551 );
 552
 553 RMS.SetProgress(95);
 554
 555 log("Creating large grass tufts...");
 556 group = new SimpleGroup(
 557         [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)]
 558 );
 559 createObjectGroups(group, 0,
 560         [avoidClasses(clHill, 2, clPlayer, 2, clDirt, 1, clForest, 0), stayClasses(clLand, 5)],
 561         planetm * scaleByMapSize(13, 200)
 562 );
 563
 564 paintTerrainBasedOnHeight(1, 2, 0, tShore);
 565 paintTerrainBasedOnHeight(getMapBaseHeight(), 1, 3, tWater);
 566
 567 setSkySet(shuffleArray(["cloudless", "cumulus", "overcast"])[0]);
 568
 569 setSunRotation(randFloat(0, TWO_PI));
 570 setSunElevation(randFloat(PI/5, PI/3));
 571 setWaterWaviness(2);
 572
 573 RMS.SetProgress(100);
 574
 575 ExportMap();