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

   1 RMS.LoadLibrary("rmgen");
   2 RMS.LoadLibrary("rmbiome");
   3
   4 TILE_CENTERED_HEIGHT_MAP = true;
   5
   6 setSelectedBiome();
   7
   8 const tMainTerrain = g_Terrains.mainTerrain;
   9 const tForestFloor1 = g_Terrains.forestFloor1;
  10 const tForestFloor2 = g_Terrains.forestFloor2;
  11 const tCliff = g_Terrains.cliff;
  12 const tTier1Terrain = g_Terrains.tier1Terrain;
  13 const tTier2Terrain = g_Terrains.tier2Terrain;
  14 const tTier3Terrain = g_Terrains.tier3Terrain;
  15 const tHill = g_Terrains.hill;
  16 const tRoad = g_Terrains.road;
  17 const tRoadWild = g_Terrains.roadWild;
  18 const tTier4Terrain = g_Terrains.tier4Terrain;
  19 const tShore = g_Terrains.shore;
  20 const tWater = g_Terrains.water;
  21
  22 const oTree1 = g_Gaia.tree1;
  23 const oTree2 = g_Gaia.tree2;
  24 const oTree3 = g_Gaia.tree3;
  25 const oTree4 = g_Gaia.tree4;
  26 const oTree5 = g_Gaia.tree5;
  27 const oFruitBush = g_Gaia.fruitBush;
  28 const oMainHuntableAnimal = g_Gaia.mainHuntableAnimal;
  29 const oFish = g_Gaia.fish;
  30 const oSecondaryHuntableAnimal = g_Gaia.secondaryHuntableAnimal;
  31 const oStoneLarge = g_Gaia.stoneLarge;
  32 const oStoneSmall = g_Gaia.stoneSmall;
  33 const oMetalLarge = g_Gaia.metalLarge;
  34 const oWood = "gaia/special_treasure_wood";
  35
  36 const aGrass = g_Decoratives.grass;
  37 const aGrassShort = g_Decoratives.grassShort;
  38 const aRockLarge = g_Decoratives.rockLarge;
  39 const aRockMedium = g_Decoratives.rockMedium;
  40 const aBushMedium = g_Decoratives.bushMedium;
  41 const aBushSmall = g_Decoratives.bushSmall;
  42
  43 const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
  44 const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
  45
  46 InitMap();
  47
  48 const numPlayers = getNumPlayers();
  49 const mapSize = getMapSize();
  50
  51 var clPlayer = createTileClass();
  52 var clHill = createTileClass();
  53 var clForest = createTileClass();
  54 var clDirt = createTileClass();
  55 var clRock = createTileClass();
  56 var clMetal = createTileClass();
  57 var clFood = createTileClass();
  58 var clBaseResource = createTileClass();
  59 var clLand = createTileClass();
  60
  61 var [playerIDs, playerX, playerZ, playerAngle] = radialPlayerPlacement();
  62
  63 for (var i = 0; i < numPlayers; i++)
  64 {
  65         var id = playerIDs[i];
  66         log("Creating base for player " + id + "...");
  67
  68         var radius = scaleByMapSize(20,29);
  69         var shoreRadius = 6;
  70         var elevation = 3;
  71
  72         var hillSize = PI * radius * radius;
  73         // get the x and z in tiles
  74         var fx = fractionToTiles(playerX[i]);
  75         var fz = fractionToTiles(playerZ[i]);
  76         var ix = round(fx);
  77         var iz = round(fz);
  78         // create the hill
  79         var placer = new ClumpPlacer(hillSize, 0.80, 0.1, 10, ix, iz);
  80         var terrainPainter = new LayeredPainter(
  81                 [tMainTerrain , tMainTerrain, tMainTerrain],            // terrains
  82                 [1, shoreRadius]                // widths
  83         );
  84         var elevationPainter = new SmoothElevationPainter(
  85                 ELEVATION_SET,                  // type
  86                 elevation,                              // elevation
  87                 shoreRadius                             // blend radius
  88         );
  89         createArea(placer, [terrainPainter, elevationPainter, paintClass(clPlayer)], null);
  90
  91         placeCivDefaultEntities(fx, fz, id, { 'iberWall': 'towers' });
  92
  93         placeDefaultChicken(fx, fz, clBaseResource);
  94
  95         // create berry bushes
  96         var bbAngle = randFloat(0, TWO_PI);
  97         var bbDist = 12;
  98         var bbX = round(fx + bbDist * cos(bbAngle));
  99         var bbZ = round(fz + bbDist * sin(bbAngle));
 100         var group = new SimpleGroup(
 101                 [new SimpleObject(oFruitBush, 5,5, 0,3)],
 102                 true, clBaseResource, bbX, bbZ
 103         );
 104         createObjectGroup(group, 0);
 105
 106         // create woods
 107         var bbAngle = randFloat(0, TWO_PI);
 108         var bbDist = 13;
 109         var bbX = round(fx + bbDist * cos(bbAngle));
 110         var bbZ = round(fz + bbDist * sin(bbAngle));
 111         group = new SimpleGroup(
 112                 [new SimpleObject(oWood, 14,14, 0,3)],
 113                 true, clBaseResource, bbX, bbZ
 114         );
 115         createObjectGroup(group, 0);
 116
 117         // create metal mine
 118         var mAngle = bbAngle;
 119         while(abs(mAngle - bbAngle) < PI/3)
 120         {
 121                 mAngle = randFloat(0, TWO_PI);
 122         }
 123         var mDist = 12;
 124         var mX = round(fx + mDist * cos(mAngle));
 125         var mZ = round(fz + mDist * sin(mAngle));
 126         group = new SimpleGroup(
 127                 [new SimpleObject(oMetalLarge, 1,1, 0,0)],
 128                 true, clBaseResource, mX, mZ
 129         );
 130         createObjectGroup(group, 0);
 131
 132         // create stone mines
 133         mAngle += randFloat(PI/8, PI/4);
 134         mX = round(fx + mDist * cos(mAngle));
 135         mZ = round(fz + mDist * sin(mAngle));
 136         group = new SimpleGroup(
 137                 [new SimpleObject(oStoneLarge, 1,1, 0,2)],
 138                 true, clBaseResource, mX, mZ
 139         );
 140         createObjectGroup(group, 0);
 141         var hillSize = PI * radius * radius;
 142         // create starting trees
 143         var num = 5;
 144         var tAngle = randFloat(-PI/3, 4*PI/3);
 145         var tDist = randFloat(12, 13);
 146         var tX = round(fx + tDist * cos(tAngle));
 147         var tZ = round(fz + tDist * sin(tAngle));
 148         group = new SimpleGroup(
 149                 [new SimpleObject(oTree1, num, num, 0,3)],
 150                 false, clBaseResource, tX, tZ
 151         );
 152         createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
 153
 154         placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
 155
 156         //create docks
 157         var dockLocation = getTIPIADBON([ix, iz], [mapSize / 2, mapSize / 2], [-3 , 2.6], 0.5, 3);
 158         if (dockLocation !== undefined)
 159                 placeObject(dockLocation[0], dockLocation[1], "structures/" + getCivCode(id-1) + "_dock", id, playerAngle[i] + PI);
 160 }
 161
 162 var landAreas = [];
 163 var playerConstraint = new AvoidTileClassConstraint(clPlayer, floor(scaleByMapSize(12,16)));
 164 var landConstraint = new AvoidTileClassConstraint(clLand, floor(scaleByMapSize(12,16)));
 165
 166 for (var x = 0; x < mapSize; ++x)
 167         for (var z = 0; z < mapSize; ++z)
 168                 if (playerConstraint.allows(x, z) && landConstraint.allows(x, z))
 169                         landAreas.push([x, z]);
 170
 171 var chosenPoint;
 172 var landAreaLen;
 173
 174 log("Creating big islands...");
 175 for (let i = 0; i < scaleByMapSize(4, 14); ++i)
 176 {
 177         landAreaLen = landAreas.length;
 178         if (!landAreaLen)
 179                 break;
 180
 181         chosenPoint = pickRandom(landAreas);
 182
 183         var newIsland = createAreas(
 184                 new ChainPlacer(
 185                         Math.floor(scaleByMapSize(4, 8)),
 186                         Math.floor(scaleByMapSize(8, 14)),
 187                         Math.floor(scaleByMapSize(25, 60)),
 188                         0.07,
 189                         chosenPoint[0],
 190                         chosenPoint[1],
 191                         scaleByMapSize(30, 70)),
 192                 [
 193                         new LayeredPainter([tMainTerrain, tMainTerrain], [2]),
 194                         new SmoothElevationPainter(ELEVATION_SET, 3, 6),
 195                         paintClass(clLand)
 196                 ],
 197                 avoidClasses(clLand, 3, clPlayer, 3),
 198                 1,
 199                 1);
 200
 201         if (newIsland && newIsland.length)
 202         {
 203                 var n = 0;
 204                 for (var j = 0; j < landAreas.length; ++j)
 205                 {
 206                         let [x, z] = landAreas[j];
 207                         if (playerConstraint.allows(x, z) && landConstraint.allows(x, z))
 208                                 landAreas[n++] = landAreas[j];
 209                 }
 210                 landAreas.length = n;
 211         }
 212 }
 213
 214 playerConstraint = new AvoidTileClassConstraint(clPlayer, floor(scaleByMapSize(9,12)));
 215 landConstraint = new AvoidTileClassConstraint(clLand, floor(scaleByMapSize(9,12)));
 216
 217 log("Creating small islands...");
 218 for (let i = 0; i < 6 * Math.square(scaleByMapSize(1, 3)); ++i)
 219 {
 220         landAreaLen = landAreas.length;
 221         if (!landAreaLen)
 222                 break;
 223
 224         chosenPoint = pickRandom(landAreas);
 225
 226         createAreas(
 227                 new ChainPlacer(
 228                         Math.floor(scaleByMapSize(4, 7)),
 229                         Math.floor(scaleByMapSize(7, 10)),
 230                         Math.floor(scaleByMapSize(16, 40)),
 231                         0.07,
 232                         chosenPoint[0],
 233                         chosenPoint[1],
 234                         scaleByMapSize(22, 40)),
 235                 [
 236                         new LayeredPainter([tMainTerrain, tMainTerrain], [2]),
 237                         new SmoothElevationPainter(ELEVATION_SET, 3, 6),
 238                         paintClass(clLand)
 239                 ],
 240                 avoidClasses(clLand, 3, clPlayer, 3),
 241                 1,
 242                 1);
 243
 244         if (newIsland !== undefined)
 245         {
 246                 var temp = [];
 247                 for (var j = 0; j < landAreaLen; ++j)
 248                 {
 249                         let [x, z] = landAreas[j];
 250                         if (playerConstraint.allows(x, z) && landConstraint.allows(x, z))
 251                                         temp.push([x, z]);
 252                 }
 253                 landAreas = temp;
 254         }
 255 }
 256 paintTerrainBasedOnHeight(1, 3, 0, tShore);
 257 paintTerrainBasedOnHeight(-8, 1, 2, tWater);
 258
 259 for (var i = 0; i < numPlayers; i++)
 260 {
 261         var fx = fractionToTiles(playerX[i]);
 262         var fz = fractionToTiles(playerZ[i]);
 263         var ix = round(fx);
 264         var iz = round(fz);
 265         // create the city patch
 266         var cityRadius = radius/3;
 267         placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
 268         var painter = new LayeredPainter([tRoadWild, tRoad], [1]);
 269         createArea(placer, painter, null);
 270 }
 271
 272 log("Creating bumps...");
 273 createAreas(
 274         new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1),
 275         new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2),
 276         [avoidClasses(clPlayer, 0), stayClasses(clLand, 3)],
 277         scaleByMapSize(20, 100));
 278
 279 log("Creating hills...");
 280 createAreas(
 281         new ChainPlacer(1, Math.floor(scaleByMapSize(4, 6)), Math.floor(scaleByMapSize(16, 40)), 0.5),
 282         [
 283                 new LayeredPainter([tCliff, tHill], [2]),
 284                 new SmoothElevationPainter(ELEVATION_SET, 18, 2),
 285                 paintClass(clHill)
 286         ],
 287         [avoidClasses(clPlayer, 2, clHill, 15), stayClasses(clLand, 0)],
 288         scaleByMapSize(4, 13));
 289
 290 // calculate desired number of trees for map (based on size)
 291 if (currentBiome() == "savanna")
 292 {
 293         var MIN_TREES = 200;
 294         var MAX_TREES = 1250;
 295         var P_FOREST = 0;
 296 }
 297 else if (currentBiome() == "tropic")
 298 {
 299         var MIN_TREES = 1000;
 300         var MAX_TREES = 6000;
 301         var P_FOREST = 0.52;
 302 }
 303 else
 304 {
 305         var MIN_TREES = 500;
 306         var MAX_TREES = 3000;
 307         var P_FOREST = 0.7;
 308 }
 309 var totalTrees = scaleByMapSize(MIN_TREES, MAX_TREES);
 310 var numForest = totalTrees * P_FOREST;
 311 var numStragglers = totalTrees * (1.0 - P_FOREST);
 312
 313 log("Creating forests...");
 314 var types = [
 315         [[tForestFloor2, tMainTerrain, pForest1], [tForestFloor2, pForest1]],
 316         [[tForestFloor1, tMainTerrain, pForest2], [tForestFloor1, pForest2]]
 317 ];
 318
 319 if (currentBiome() != "savanna")
 320 {
 321         var size = numForest / (scaleByMapSize(3,6) * numPlayers);
 322         var num = floor(size / types.length);
 323         for (let type of types)
 324                 createAreas(
 325                         new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), numForest / (num * Math.floor(scaleByMapSize(2, 5))), 0.5),
 326                         [
 327                                 new LayeredPainter(type, [2]),
 328                                 paintClass(clForest)
 329                         ],
 330                         [avoidClasses(clPlayer, 0, clForest, 10, clHill, 0), stayClasses(clLand, 6)],
 331                         num);
 332 }
 333
 334 RMS.SetProgress(50);
 335 log("Creating dirt patches...");
 336 var numberOfPatches = scaleByMapSize(15, 45) * (currentBiome() == "savanna" ? 3 : 1);
 337 for (let size of [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)])
 338         createAreas(
 339                 new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
 340                 [
 341                         new LayeredPainter([[tMainTerrain, tTier1Terrain], [tTier1Terrain, tTier2Terrain], [tTier2Terrain, tTier3Terrain]], [1, 1]),
 342                         paintClass(clDirt)
 343                 ],
 344                 [avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 0), stayClasses(clLand, 6)],
 345                 numberOfPatches);
 346
 347 log("Creating grass patches...");
 348 for (let size of [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)])
 349         createAreas(
 350                 new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
 351                 new TerrainPainter(tTier4Terrain),
 352                 [avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 0), stayClasses(clLand, 6)],
 353                 numberOfPatches);
 354
 355 RMS.SetProgress(55);
 356
 357 log("Creating stone mines...");
 358 var group = new SimpleGroup([new SimpleObject(oStoneSmall, 0, 2, 0, 4), new SimpleObject(oStoneLarge, 1, 1, 0, 4)], true, clRock);
 359 createObjectGroupsDeprecated(group, 0,
 360         [avoidClasses(clForest, 1, clPlayer, 0, clRock, 10, clHill, 1), stayClasses(clLand, 5)],
 361         scaleByMapSize(4,16), 100
 362 );
 363
 364 log("Creating small stone quarries...");
 365 group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
 366 createObjectGroupsDeprecated(group, 0,
 367         [avoidClasses(clForest, 1, clPlayer, 0, clRock, 10, clHill, 1), stayClasses(clLand, 5)],
 368         scaleByMapSize(4,16), 100
 369 );
 370
 371 log("Creating metal mines...");
 372 group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
 373 createObjectGroupsDeprecated(group, 0,
 374         [avoidClasses(clForest, 1, clPlayer, 0, clMetal, 10, clRock, 5, clHill, 1), stayClasses(clLand, 5)],
 375         scaleByMapSize(4,16), 100
 376 );
 377
 378 RMS.SetProgress(65);
 379
 380 log("Creating small decorative rocks...");
 381 group = new SimpleGroup(
 382         [new SimpleObject(aRockMedium, 1,3, 0,1)],
 383         true
 384 );
 385 createObjectGroupsDeprecated(
 386         group, 0,
 387         [avoidClasses(clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 5)],
 388         scaleByMapSize(16, 262), 50
 389 );
 390
 391 log("Creating large decorative rocks...");
 392 group = new SimpleGroup(
 393         [new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
 394         true
 395 );
 396 createObjectGroupsDeprecated(
 397         group, 0,
 398         [avoidClasses(clForest, 0, clPlayer, 0, clHill, 0), stayClasses(clLand, 5)],
 399         scaleByMapSize(8, 131), 50
 400 );
 401
 402 RMS.SetProgress(70);
 403
 404 log("Creating deer...");
 405 group = new SimpleGroup(
 406         [new SimpleObject(oMainHuntableAnimal, 5,7, 0,4)],
 407         true, clFood
 408 );
 409 createObjectGroupsDeprecated(group, 0,
 410         [avoidClasses(clForest, 0, clPlayer, 0, clHill, 1, clFood, 20), stayClasses(clLand, 5)],
 411         3 * numPlayers, 50
 412 );
 413
 414 RMS.SetProgress(75);
 415
 416 log("Creating sheep...");
 417 group = new SimpleGroup(
 418         [new SimpleObject(oSecondaryHuntableAnimal, 2,3, 0,2)],
 419         true, clFood
 420 );
 421 createObjectGroupsDeprecated(group, 0,
 422         [avoidClasses(clForest, 0, clPlayer, 0, clHill, 1, clFood, 20), stayClasses(clLand, 5)],
 423         3 * numPlayers, 50
 424 );
 425
 426 log("Creating fruit bush...");
 427 group = new SimpleGroup(
 428         [new SimpleObject(oFruitBush, 5,7, 0,4)],
 429         true, clFood
 430 );
 431 createObjectGroupsDeprecated(group, 0,
 432         [avoidClasses(clForest, 0, clPlayer, 8, clHill, 1, clFood, 20), stayClasses(clLand, 5)],
 433         randIntInclusive(1, 4) * numPlayers + 2, 50
 434 );
 435
 436 log("Creating fish...");
 437 group = new SimpleGroup(
 438         [new SimpleObject(oFish, 2,3, 0,2)],
 439         true, clFood
 440 );
 441 createObjectGroupsDeprecated(group, 0,
 442         avoidClasses(clLand, 4, clForest, 2, clPlayer, 2, clHill, 2, clFood, 20),
 443         25 * numPlayers, 60
 444 );
 445
 446 RMS.SetProgress(85);
 447
 448 log("Creating straggler trees...");
 449 var types = [oTree1, oTree2, oTree4, oTree3];
 450 var num = floor(numStragglers / types.length);
 451 for (let type of types)
 452         createObjectGroupsDeprecated(
 453                 new SimpleGroup([new SimpleObject(type, 1, 1, 0, 3)], true, clForest),
 454                 0,
 455                 [avoidClasses(clForest, 1, clHill, 1, clPlayer, 0, clMetal, 6, clRock, 6), stayClasses(clLand, 6)],
 456                 num);
 457
 458 var planetm = 1;
 459 if (currentBiome() == "tropic")
 460         planetm = 8;
 461
 462 log("Creating small grass tufts...");
 463 group = new SimpleGroup(
 464         [new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)]
 465 );
 466 createObjectGroupsDeprecated(group, 0,
 467         [avoidClasses(clHill, 2, clPlayer, 2, clDirt, 0), stayClasses(clLand, 6)],
 468         planetm * scaleByMapSize(13, 200)
 469 );
 470
 471 RMS.SetProgress(90);
 472
 473 log("Creating large grass tufts...");
 474 group = new SimpleGroup(
 475         [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)]
 476 );
 477 createObjectGroupsDeprecated(group, 0,
 478         [avoidClasses(clHill, 2, clPlayer, 2, clDirt, 1, clForest, 0), stayClasses(clLand, 5)],
 479         planetm * scaleByMapSize(13, 200)
 480 );
 481
 482 RMS.SetProgress(95);
 483
 484 log("Creating bushes...");
 485 group = new SimpleGroup(
 486         [new SimpleObject(aBushMedium, 1,2, 0,2), new SimpleObject(aBushSmall, 2,4, 0,2)]
 487 );
 488 createObjectGroupsDeprecated(group, 0,
 489         [avoidClasses(clHill, 1, clPlayer, 1, clDirt, 1), stayClasses(clLand, 6)],
 490         planetm * scaleByMapSize(13, 200), 50
 491 );
 492
 493 setSkySet(pickRandom(["cirrus", "cumulus", "sunny"]));
 494 setSunRotation(randFloat(0, TWO_PI));
 495 setSunElevation(randFloat(PI/ 5, PI / 3));
 496 setWaterWaviness(2);
 497
 498 ExportMap();