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

   1 Engine.LoadLibrary("rmgen");
   2 Engine.LoadLibrary("rmbiome");
   3
   4 setSelectedBiome();
   5
   6 const tMainTerrain = g_Terrains.mainTerrain;
   7 const tForestFloor1 = g_Terrains.forestFloor1;
   8 const tForestFloor2 = g_Terrains.forestFloor2;
   9 const tCliff = g_Terrains.cliff;
  10 const tTier1Terrain = g_Terrains.tier1Terrain;
  11 const tTier2Terrain = g_Terrains.tier2Terrain;
  12 const tTier3Terrain = g_Terrains.tier3Terrain;
  13 const tRoad = g_Terrains.road;
  14 const tRoadWild = g_Terrains.roadWild;
  15 const tTier4Terrain = g_Terrains.tier4Terrain;
  16 const tShore = g_Terrains.shore;
  17 const tWater = g_Terrains.water;
  18
  19 var tHill = g_Terrains.hill;
  20 var tDirt = g_Terrains.dirt;
  21 if (currentBiome() == "temperate")
  22 {
  23         tDirt = ["medit_shrubs_a", "grass_field"];
  24         tHill = ["grass_field", "peat_temp"];
  25 }
  26
  27 const oTree1 = g_Gaia.tree1;
  28 const oTree2 = g_Gaia.tree2;
  29 const oTree3 = g_Gaia.tree3;
  30 const oTree4 = g_Gaia.tree4;
  31 const oTree5 = g_Gaia.tree5;
  32 const oFruitBush = g_Gaia.fruitBush;
  33 const oMainHuntableAnimal = g_Gaia.mainHuntableAnimal;
  34 const oFish = g_Gaia.fish;
  35 const oSecondaryHuntableAnimal = g_Gaia.secondaryHuntableAnimal;
  36 const oStoneLarge = g_Gaia.stoneLarge;
  37 const oMetalLarge = g_Gaia.metalLarge;
  38
  39 const aGrass = g_Decoratives.grass;
  40 const aGrassShort = g_Decoratives.grassShort;
  41 const aRockLarge = g_Decoratives.rockLarge;
  42 const aRockMedium = g_Decoratives.rockMedium;
  43 const aBushMedium = g_Decoratives.bushMedium;
  44 const aBushSmall = g_Decoratives.bushSmall;
  45
  46 const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
  47 const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
  48
  49 InitMap();
  50
  51 const clPlayer = createTileClass();
  52 const clHill = createTileClass();
  53 const clMountain = createTileClass();
  54 const clForest = createTileClass();
  55 const clDirt = createTileClass();
  56 const clRock = createTileClass();
  57 const clMetal = createTileClass();
  58 const clFood = createTileClass();
  59 const clBaseResource = createTileClass();
  60
  61 const numPlayers = getNumPlayers();
  62 const mapSize = getMapSize();
  63 const centerOfMap = mapSize / 2;
  64
  65 const landHeight = 2;
  66 const waterHeight = getMapBaseHeight();
  67 const shoreRadius = 6;
  68
  69 initTerrain(tWater);
  70
  71 log("Creating the water...");
  72 createArea(
  73         new ClumpPlacer(getMapArea(), 1, 1, 1, Math.round(fractionToTiles(0.5)), Math.round(fractionToTiles(0.5))),
  74         [
  75                 new LayeredPainter([tWater, tWater, tShore], [1, 4]),
  76                 new SmoothElevationPainter(ELEVATION_SET, waterHeight, 2)
  77         ],
  78         avoidClasses(clPlayer, 5));
  79
  80 log("Creating player islands...")
  81 var [playerIDs, playerX, playerZ] = playerPlacementCircle(0.38);
  82
  83 for (let i = 0; i < numPlayers; ++i)
  84         createArea(
  85                 new ClumpPlacer(
  86                         2 * diskArea(defaultPlayerBaseRadius()),
  87                         0.8,
  88                         0.1,
  89                         10,
  90                         Math.round(fractionToTiles(playerX[i])),
  91                         Math.round(fractionToTiles(playerZ[i]))),
  92                 [
  93                         new LayeredPainter([tShore, tMainTerrain], [shoreRadius]),
  94                         new SmoothElevationPainter(ELEVATION_SET, landHeight, shoreRadius),
  95                         paintClass(clHill)
  96                 ],
  97                 null);
  98
  99 placePlayerBases({
 100         "PlayerPlacement": [playerIDs, playerX, playerZ],
 101         "PlayerTileClass": clPlayer,
 102         "BaseResourceClass": clBaseResource,
 103         "Walls": false,
 104         "CityPatch": {
 105                 "outerTerrain": tRoadWild,
 106                 "innerTerrain": tRoad
 107         },
 108         "Chicken": {
 109         },
 110         "Berries": {
 111                 "template": oFruitBush
 112         },
 113         "Mines": {
 114                 "types": [
 115                         { "template": oMetalLarge },
 116                         { "template": oStoneLarge }
 117                 ]
 118         },
 119         "Trees": {
 120                 "template": oTree2,
 121                 "count": 50,
 122                 "maxDist": 16,
 123                 "maxDistGroup": 7
 124         },
 125         "Decoratives": {
 126                 "template": aGrassShort
 127         }
 128 });
 129 Engine.SetProgress(40);
 130
 131 log("Creating central island...");
 132 createArea(
 133         new ChainPlacer(
 134                 6,
 135                 Math.floor(scaleByMapSize(10, 15)),
 136                 Math.floor(scaleByMapSize(200, 300)),
 137                 1,
 138                 centerOfMap,
 139                 centerOfMap,
 140                 0,
 141                 [Math.floor(mapSize * 0.01)]),
 142         [
 143                 new LayeredPainter([tShore, tMainTerrain], [shoreRadius, 100]),
 144                 new SmoothElevationPainter(ELEVATION_SET, landHeight, shoreRadius),
 145                 paintClass(clHill)
 146         ],
 147         avoidClasses(clPlayer, 40));
 148
 149 for (let m = 0; m < randIntInclusive(20, 34); ++m)
 150 {
 151         let elevRand = randIntInclusive(6, 20);
 152         createArea(
 153                 new ChainPlacer(
 154                         7,
 155                         15,
 156                         Math.floor(scaleByMapSize(15, 20)),
 157                         1,
 158                         randIntExclusive(0, mapSize),
 159                         randIntExclusive(0, mapSize),
 160                         0,
 161                         [Math.floor(mapSize * 0.01)]),
 162                 [
 163                         new LayeredPainter([tDirt, tHill], [Math.floor(elevRand / 3), 40]),
 164                         new SmoothElevationPainter(ELEVATION_SET, elevRand, Math.floor(elevRand / 3)),
 165                         paintClass(clHill)
 166                 ],
 167                 [avoidClasses(clBaseResource, 2, clPlayer, 40), stayClasses(clHill, 6)]);
 168 }
 169
 170 for (let m = 0; m < randIntInclusive(8, 17); ++m)
 171 {
 172         let elevRand = randIntInclusive(15, 29);
 173         createArea(
 174                 new ChainPlacer(
 175                                 5,
 176                                 8,
 177                                 Math.floor(scaleByMapSize(15, 20)),
 178                                 1,
 179                                 randIntExclusive(0, mapSize),
 180                                 randIntExclusive(0, mapSize),
 181                                 0,
 182                                 [Math.floor(mapSize * 0.01)]),
 183                 [
 184                         new LayeredPainter([tCliff, tForestFloor2], [Math.floor(elevRand / 3), 40]),
 185                         new SmoothElevationPainter(ELEVATION_MODIFY, elevRand, Math.floor(elevRand / 3)),
 186                         paintClass(clMountain)
 187                 ],
 188                 [avoidClasses(clBaseResource, 2, clPlayer, 40), stayClasses(clHill, 6)]);
 189 }
 190
 191 log("Creating center bounty...");
 192 createObjectGroup(
 193         new SimpleGroup(
 194                 [new SimpleObject(oMetalLarge, 3, 6, 25, Math.floor(mapSize * 0.25))],
 195                 true,
 196                 clBaseResource,
 197                 centerOfMap,
 198                 centerOfMap),
 199         0,
 200         [avoidClasses(clBaseResource, 20, clPlayer, 40, clMountain, 4), stayClasses(clHill, 10)]);
 201
 202 createObjectGroup(
 203         new SimpleGroup(
 204                 [new SimpleObject(oStoneLarge, 3, 6, 25, Math.floor(mapSize * 0.25))],
 205                 true,
 206                 clBaseResource,
 207                 centerOfMap,
 208                 centerOfMap),
 209                 0,
 210                 [avoidClasses(clBaseResource, 20, clPlayer, 40, clMountain, 4), stayClasses(clHill, 10)]);
 211
 212 log("Creating fish...");
 213 createObjectGroupsDeprecated(
 214         new SimpleGroup([new SimpleObject(oFish, 2, 3, 0, 2)], true, clFood),
 215         0,
 216         avoidClasses(clHill, 10, clFood, 20),
 217         10 * numPlayers,
 218         60);
 219
 220 var [forestTrees, stragglerTrees] = getTreeCounts(...rBiomeTreeCount(0.7));
 221 createForests(
 222         [tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
 223         [avoidClasses(clPlayer, 25, clForest, 10, clBaseResource, 3, clMetal, 6, clRock, 3, clMountain, 2), stayClasses(clHill, 6)],
 224         clForest,
 225         forestTrees);
 226
 227 let types = [oTree1, oTree2, oTree4, oTree3];
 228 createStragglerTrees(
 229         types,
 230         [avoidClasses(clBaseResource, 2, clMetal, 6, clRock, 3, clMountain, 2, clPlayer, 25), stayClasses(clHill, 6)],
 231         clForest,
 232         stragglerTrees);
 233 Engine.SetProgress(65);
 234
 235 log("Creating dirt patches...");
 236 var numb = currentBiome() == "savanna" ? 3 : 1;
 237 for (let size of [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)])
 238         createAreas(
 239                 new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
 240                 [
 241                         new LayeredPainter([[tMainTerrain, tTier1Terrain], [tTier1Terrain, tTier2Terrain], [tTier2Terrain, tTier3Terrain]], [1, 1]),
 242                         paintClass(clDirt)
 243                 ],
 244                 avoidClasses(clForest, 0, clMountain, 0, clDirt, 5, clPlayer, 10),
 245                 numb * scaleByMapSize(15, 45));
 246
 247 log("Painting shorelines...");
 248 paintTerrainBasedOnHeight(1, landHeight, 0, tMainTerrain);
 249 paintTerrainBasedOnHeight(waterHeight, 1, 3, tTier1Terrain);
 250
 251 log("Creating grass patches...");
 252 for (let size of [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)])
 253         createAreas(
 254                 new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
 255                 new TerrainPainter(tTier4Terrain),
 256                 avoidClasses(clForest, 0, clMountain, 0, clDirt, 5, clPlayer, 10),
 257                 numb * scaleByMapSize(15, 45));
 258
 259 log("Creating food...");
 260 createFood(
 261         [
 262                 [new SimpleObject(oMainHuntableAnimal, 5, 7, 0, 4)],
 263                 [new SimpleObject(oSecondaryHuntableAnimal, 2, 3, 0, 2)]
 264         ],
 265         [3 * numPlayers, 3 * numPlayers],
 266         [avoidClasses(clForest, 0, clPlayer, 20, clMountain, 1, clFood, 4, clRock, 6, clMetal, 6), stayClasses(clHill, 6)],
 267         clFood);
 268
 269 Engine.SetProgress(75);
 270
 271 createFood(
 272         [
 273                 [new SimpleObject(oFruitBush, 5, 7, 0, 4)]
 274         ],
 275         [3 * numPlayers],
 276         [avoidClasses(clForest, 0, clPlayer, 15, clMountain, 1, clFood, 4, clRock, 6, clMetal, 6), stayClasses(clHill, 6)],
 277         clFood);
 278
 279 Engine.SetProgress(85);
 280
 281 log("Creating decoration...");
 282 var planetm = currentBiome() == "tropic" ? 8 : 1;
 283 createDecoration(
 284         [
 285                 [new SimpleObject(aRockMedium, 1, 3, 0, 1)],
 286                 [new SimpleObject(aRockLarge, 1, 2, 0, 1), new SimpleObject(aRockMedium, 1, 3, 0, 2)],
 287                 [new SimpleObject(aGrassShort, 2, 15, 0, 1)],
 288                 [new SimpleObject(aGrass, 2, 10, 0, 1.8), new SimpleObject(aGrassShort, 3, 10, 1.2, 2.5)],
 289                 [new SimpleObject(aBushMedium, 1, 5, 0, 2), new SimpleObject(aBushSmall, 2, 4, 0, 2)]
 290         ],
 291         [
 292                 scaleByMapSize(16, 262),
 293                 scaleByMapSize(8, 131),
 294                 planetm * scaleByMapSize(13, 200),
 295                 planetm * scaleByMapSize(13, 200),
 296                 planetm * scaleByMapSize(13, 200)
 297         ],
 298         avoidClasses(clForest, 2, clPlayer, 20, clMountain, 5, clFood, 1, clBaseResource, 2));
 299
 300 log("Creating water forests...");
 301 var [forestTrees, stragglerTrees] = getTreeCounts(...rBiomeTreeCount(0.1));
 302 createForests(
 303         [tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
 304         avoidClasses(clPlayer, 30, clHill, 10, clFood, 5),
 305         clForest,
 306         forestTrees);
 307
 308 log("Creating small grass tufts...");
 309 createObjectGroupsDeprecated(
 310         new SimpleGroup([new SimpleObject(aGrassShort, 1, 2, 0, 1)]),
 311         0,
 312         [avoidClasses(clMountain, 2, clPlayer, 2, clDirt, 0), stayClasses(clHill, 8)],
 313         planetm * scaleByMapSize(13, 200));
 314
 315 placePlayersNomad(
 316         clPlayer,
 317         new AndConstraint([
 318                 stayClasses(clHill, 2),
 319                 avoidClasses(clMountain, 2, clForest, 1, clMetal, 4, clRock, 4, clFood, 2)]));
 320
 321 setSkySet(pickRandom(["cloudless", "cumulus", "overcast"]));
 322 setWaterMurkiness(0.4);
 323
 324 ExportMap();