dallasgroot/0ad
1
0
Fork 0
mirror of https://gitea.wildfiregames.com/0ad/0ad synced 2026-07-04 05:55:47 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

Delete the remains of rmgen/utilityfunctions.js, refs #4804 by

Browse source 
cleaning up the createForests function.

Remove g_numStragglerTrees and clForest references from the rmgen
library.
Compute the number of forest- and straggler trees in a new function
instead of hiding it and obstructing the placement code.
Remove unused numMultiplier argument.

Replace duplication of these three functions with calls to them, refs
#4805.
Remove duplicate random biome JSON constants of the Islands, Migration
and Snowflake Searocks map.
There is significant partial createForests duplication that should be
unified eventually.

This was SVN commit r20406.
This commit is contained in:
elexis 2017-11-04 13:04:54 +00:00
parent 822e37f70c
commit ac8f4f49fc
47 changed files with 431 additions and 711 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

17
binaries/data/mods/public/maps/random/aegean_sea.js
View file

@ -176,11 +176,12 @@ paintTerrainBasedOnHeight(1, 2, 0, tShore);
RMS.SetProgress(40);
createBumps(avoidClasses(clWater, 2, clPlayer, 20));
var [forestTrees, stragglerTrees] = getTreeCounts(500, 3000, 0.7);
createForests(
[tForestFloor, tForestFloor, tForestFloor, pForest, pForest],
avoidClasses(clPlayer, 20, clForest, 17, clWater, 2, clBaseResource, 3),
clForest
);
clForest,
forestTrees);
RMS.SetProgress(50);
@ -332,11 +333,15 @@ RMS.SetProgress(90);
var types = [oDatePalm, oSDatePalm, oCarob, oFanPalm, oPoplar, oCypress];
createStragglerTrees(
types,
avoidClasses(clForest, 1, clWater, 2, clPlayer, 12, clMetal, 6, clHill, 1));
avoidClasses(clForest, 1, clWater, 2, clPlayer, 12, clMetal, 6, clHill, 1),
clForest,
stragglerTrees);
log("Creating straggler island trees...");
g_numStragglerTrees *= 10;
createStragglerTrees(types, stayClasses(clIsland, 4));
createStragglerTrees(
types,
stayClasses(clIsland, 4),
clForest,
stragglerTrees * 10);
setSkySet("cumulus");
setSunColor(0.866667, 0.776471, 0.486275);

13
binaries/data/mods/public/maps/random/african_plains.js
View file

@ -154,12 +154,12 @@ paintTerrainBasedOnHeight(floor(scaleByMapSize(20, 40)), 100, 3, tGrass);
createBumps(avoidClasses(clWater, 2, clPlayer, 20));
var [forestTrees, stragglerTrees] = getTreeCounts(500, 3000, 0.7);
createForests(
[tPrimary, tForestFloor, tForestFloor, pForest, pForest],
avoidClasses(clPlayer, 20, clForest, 20, clHill, 0, clWater, 2),
clForest,
1.0
);
forestTrees);
log("Creating dirt patches...");
createLayeredPatches(
@ -294,14 +294,15 @@ createFood(
[
15 * numPlayers
],
[avoidClasses(clFood, 20), stayClasses(clWater, 6)]
);
[avoidClasses(clFood, 20), stayClasses(clWater, 6)],
clFood);
RMS.SetProgress(85);
createStragglerTrees(
[oBaobab],
avoidClasses(clWater, 5, clForest, 2, clHill, 3, clPlayer, 12, clMetal, 4, clRock, 4)
);
avoidClasses(clWater, 5, clForest, 2, clHill, 3, clPlayer, 12, clMetal, 4, clRock, 4),
clForest,
stragglerTrees);
setPPEffect("hdr");
setPPSaturation(0.48);

11
binaries/data/mods/public/maps/random/alpine_lakes.js
View file

@ -236,12 +236,12 @@ paintTerrainBasedOnHeight(floor(scaleByMapSize(20, 40)), 100, 3, tSnowLimited);
createBumps(avoidClasses(clWater, 2, clPlayer, 20));
var [forestTrees, stragglerTrees] = getTreeCounts(500, 3000, 0.7);
createForests(
[tPrimary, tForestFloor, tForestFloor, pForest, pForest],
avoidClasses(clPlayer, 20, clForest, 17, clHill, 0, clWater, 2),
clForest,
1.0
);
forestTrees);
RMS.SetProgress(60);
@ -340,8 +340,11 @@ createFood
RMS.SetProgress(85);
var types = [oPine];
createStragglerTrees(types, avoidClasses(clWater, 5, clForest, 3, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6));
createStragglerTrees(
[oPine],
avoidClasses(clWater, 5, clForest, 3, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6),
clForest,
stragglerTrees);
setSkySet(pickRandom(["cirrus", "cumulus", "sunny"]));
setSunRotation(randFloat(0, TWO_PI));

28
binaries/data/mods/public/maps/random/alpine_valley.js
View file

@ -378,26 +378,18 @@ createAreas(
);
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 [forestTrees, stragglerTrees] = getTreeCounts(500, 3000, 0.7);
var types = [
[[tForestFloor, tPrimary, pForest], [tForestFloor, pForest]]
];
var size = numForest / (scaleByMapSize(2,8) * numPlayers);
var size = forestTrees / (scaleByMapSize(2,8) * numPlayers);
var num = Math.floor(size / types.length);
for (let type of types)
createAreas(
new ClumpPlacer(numForest / num, 0.1, 0.1, 1),
new ClumpPlacer(forestTrees / num, 0.1, 0.1, 1),
[
new LayeredPainter(type, [2]),
paintClass(clForest)
@ -503,15 +495,11 @@ createObjectGroupsDeprecated(group, 0,
);
RMS.SetProgress(85);
log("Creating straggler trees...");
var types = [oPine, oPine];
var num = floor(numStragglers / types.length);
for (let type of types)
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(type, 1,1, 0,3)], true, clForest),
0,
avoidClasses(clForest, 1, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6),
num);
createStragglerTrees(
[oPine],
avoidClasses(clForest, 1, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6),
clForest,
stragglerTrees);
log("Creating small grass tufts...");
var planetm = 1;

26
binaries/data/mods/public/maps/random/anatolian_plateau.js
View file

@ -129,18 +129,10 @@ createAreas(
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 [forestTrees, stragglerTrees] = getTreeCounts(220, 1000, 0.65);
var types = [[[tForestFloor, tGrass, pForest], [tForestFloor, pForest]]];
var size = numForest / (scaleByMapSize(2,8) * numPlayers);
var size = forestTrees / (scaleByMapSize(2,8) * numPlayers);
var num = 4 * floor(size / types.length);
for (let type of types)
createAreas(
@ -265,15 +257,11 @@ createObjectGroupsDeprecated(group, 0,
RMS.SetProgress(85);
log("Creating straggler trees...");
var types = [oBush, oPoplar];
var num = floor(numStragglers / types.length);
for (let type of types)
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(type, 1, 1, 0, 3)], true, clForest),
0,
avoidClasses(clForest, 1, clHill, 1, clPlayer, 13, clMetal, 6, clRock, 6),
num);
createStragglerTrees(
[oBush, oPoplar],
avoidClasses(clForest, 1, clHill, 1, clPlayer, 13, clMetal, 6, clRock, 6),
clForest,
stragglerTrees);
log("Creating large grass tufts...");
group = new SimpleGroup(

9
binaries/data/mods/public/maps/random/archipelago.js
View file

@ -195,12 +195,12 @@ if (randBool())
else
createMountains(tCliff, [avoidClasses(clPlayer, 2, clHill, 15), stayClasses(clLand, 0)], clHill, scaleByMapSize(1, 4) * numPlayers);
var [forestTrees, stragglerTrees] = getTreeCounts(...rBiomeTreeCount(1));
createForests(
[tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
[avoidClasses(clPlayer, 20, clForest, 17, clHill, 0), stayClasses(clLand, 4)],
clForest,
1,
...rBiomeTreeCount(1));
forestTrees);
RMS.SetProgress(50);
log("Creating dirt patches...");
@ -300,10 +300,11 @@ createFood
RMS.SetProgress(85);
log("Creating straggler trees...");
createStragglerTrees(
[oTree1, oTree2, oTree4, oTree3],
[avoidClasses(clForest, 7, clHill, 1, clPlayer, 3, clMetal, 6, clRock, 6), stayClasses(clLand, 7)]);
[avoidClasses(clForest, 7, clHill, 1, clPlayer, 3, clMetal, 6, clRock, 6), stayClasses(clLand, 7)],
clForest,
stragglerTrees);
setWaterWaviness(4.0);
setWaterType("ocean");

7
binaries/data/mods/public/maps/random/arctic_summer.js
View file

@ -183,6 +183,7 @@ createBumps(avoidClasses(clPlayer, 6, clWater, 2), scaleByMapSize(30, 300), 1, 8
paintTerrainBasedOnHeight(4, 15, 0, tCliff);
paintTerrainBasedOnHeight(15, 100, 3, tSnowLimited);
var [forestTrees, stragglerTrees] = getTreeCounts(500, 3000, 0.7);
createForests(
[tSecondary, tForestFloor, tForestFloor, pForest, pForest],
avoidClasses(
@ -191,7 +192,7 @@ createForests(
clHill, 20,
clWater, 2),
clForest,
1);
forestTrees);
RMS.SetProgress(60);
log("Creating dirt patches...");
@ -357,7 +358,9 @@ createStragglerTrees(
clHill, 1,
clPlayer, 12,
clMetal, 4,
clRock, 4));
clRock, 4),
clForest,
stragglerTrees);
setSkySet("sunset 1");
setSunRotation(randFloat(0, 2 * PI));

39
binaries/data/mods/public/maps/random/ardennes_forest.js
View file

@ -328,36 +328,31 @@ for (var ix = 0; ix < mapSize; ix++)
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);
var [forestTrees, stragglerTrees] = getTreeCounts(400, 6000, 0.8);
var [forestTreesJoin, forestTrees] = getTreeCounts(forestTrees, forestTrees, 0.25);
var num = forestTrees / (scaleByMapSize(6, 16) * numPlayers);
createAreasInAreas(
placer,
[painter, paintClass(clForest)],
new ClumpPlacer(forestTrees / num, 0.1, 0.1, 1),
[
new TerrainPainter(pForest),
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);
var num = forestTreesJoin / (scaleByMapSize(4,6) * numPlayers);
createAreasInAreas(
placer,
[painter, paintClass(clForest), paintClass(clForestJoin)],
new ClumpPlacer(forestTreesJoin / num, 0.1, 0.1, 1),
[
new TerrainPainter(pForest),
paintClass(clForest),
paintClass(clForestJoin)
],
[avoidClasses(clPlayer, 5, clBaseResource, 4, clForestJoin, 5, clHill, 4), borderClasses(clForest, 1, 4)],
num,
100,
@ -475,7 +470,7 @@ RMS.SetProgress(90);
log("Creating straggler trees...");
var types = [oOak, oOakLarge, oPine, oAleppoPine];
var num = floor(numStragglers / types.length);
var num = Math.floor(stragglerTrees / types.length);
for (let type of types)
createObjectGroupsByAreasDeprecated(
new SimpleGroup([new SimpleObject(type, 1, 1, 0, 3)], true, clForest),

21
binaries/data/mods/public/maps/random/atlas_mountains.js
View file

@ -135,11 +135,12 @@ createMountains(tCliff, avoidClasses(clPlayer, 20, clHill, 8), clHill, scaleByMa
RMS.SetProgress(25);
var [forestTrees, stragglerTrees] = getTreeCounts(500, 3000, 0.7);
createForests(
[tGrass, tForestFloor, tForestFloor, pForest1, pForest2],
avoidClasses(clPlayer, 20, clForest, 14, clHill, 1),
clForest,
0.6);
forestTrees);
RMS.SetProgress(40);
@ -250,17 +251,15 @@ RMS.SetProgress(80);
createStragglerTrees(
[oCarob, oAleppoPine],
avoidClasses(clForest, 1, clHill, 1, clPlayer, 10, clMetal, 6, clRock, 6, clTreasure, 4));
avoidClasses(clForest, 1, clHill, 1, clPlayer, 10, clMetal, 6, clRock, 6, clTreasure, 4),
clForest,
stragglerTrees);
log("Creating hill trees...");
var types = [aCarob, aAleppoPine];
var num = floor(0.2 * g_numStragglerTrees / types.length);
for (let type of types)
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(type, 1, 1, 0, 3)], true, clForest),
0,
stayClasses(clHill, 2),
num);
createStragglerTrees(
[aCarob, aAleppoPine],
stayClasses(clHill, 2),
clForest,
stragglerTrees / 5);
setFogFactor(0.2);
setFogThickness(0.14);

16
binaries/data/mods/public/maps/random/botswanan_haven.js
View file

@ -375,17 +375,11 @@ createObjectGroupsDeprecated(
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));
createStragglerTrees(
[oToona, oBaobab, oBush, oBush],
avoidClasses(clForest, 1, clWater, 1, clHill, 1, clPlayer, 13, clMetal, 1, clRock, 1),
clForest,
scaleByMapSize(60, 500));
RMS.SetProgress(85);
log("Creating small grass tufts...");

9
binaries/data/mods/public/maps/random/cantabrian_highlands.js
View file

@ -209,11 +209,12 @@ log("Creating hills...");
createHills([tCliff, tCliff, tHill], avoidClasses(clPlayer, 2, clWater, 5, clHill, 15), clHill, scaleByMapSize(1, 4) * numPlayers);
RMS.SetProgress(35);
var [forestTrees, stragglerTrees] = getTreeCounts(500, 3000, 0.7);
createForests(
[tGrass, tGrassDForest, tGrassPForest, pForestP, pForestD],
avoidClasses(clPlayer, 1, clWater, 3, clForest, 17, clHill, 1),
clForest
);
clForest,
forestTrees);
RMS.SetProgress(40);
log("Creating dirt patches...");
@ -303,7 +304,9 @@ RMS.SetProgress(85);
createStragglerTrees(
[oOak, oOakLarge, oPine, oApple],
avoidClasses(clWater, 1, clForest, 1, clHill, 1, clPlayer, 1, clMetal, 6, clRock, 6));
avoidClasses(clWater, 1, clForest, 1, clHill, 1, clPlayer, 1, clMetal, 6, clRock, 6),
clForest,
stragglerTrees);
RMS.SetProgress(90);
setSkySet("cirrus");

10
binaries/data/mods/public/maps/random/canyon.js
View file

@ -300,13 +300,12 @@ createHills([tCliff, tCliff, tHill], [avoidClasses(clPlayer, 2, clHill, 8, clHil
// create hills outside the canyon
createHills([tCliff, tCliff, tMainTerrain], avoidClasses(clLand, 1, clHill, 1), clHill, scaleByMapSize(20, 150), undefined, undefined, undefined, undefined, 40);
var [forestTrees, stragglerTrees] = getTreeCounts(...rBiomeTreeCount(1));
createForests(
[tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
[avoidClasses(clPlayer, 1, clForest, 15, clHill, 1, clHill2, 0), stayClasses(clLand, 4)],
clForest,
1,
...rBiomeTreeCount(1)
);
forestTrees);
RMS.SetProgress(50);
@ -409,10 +408,11 @@ createFood
RMS.SetProgress(85);
log("Creating straggler trees...");
createStragglerTrees(
[oTree1, oTree2, oTree4, oTree3],
[avoidClasses(clForest, 1, clHill, 1, clPlayer, 9, clMetal, 6, clRock, 6, clHill2, 1), stayClasses(clLand, 3)]);
[avoidClasses(clForest, 1, clHill, 1, clPlayer, 9, clMetal, 6, clRock, 6, clHill2, 1), stayClasses(clLand, 3)],
clForest,
stragglerTrees);
log("Creating treasures...");
for (let i = 0; i < randIntInclusive(3, 8); ++i)

9
binaries/data/mods/public/maps/random/continent.js
View file

@ -180,12 +180,12 @@ if (randBool())
else
createMountains(tCliff, [avoidClasses(clPlayer, 20, clHill, 15, clBaseResource, 3), stayClasses(clLand, 5)], clHill, scaleByMapSize(1, 4) * numPlayers);
var [forestTrees, stragglerTrees] = getTreeCounts(...rBiomeTreeCount(1));
createForests(
[tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
[avoidClasses(clPlayer, 20, clForest, 17, clHill, 0, clBaseResource,2), stayClasses(clLand, 4)],
clForest,
1.0,
...rBiomeTreeCount(1));
forestTrees);
RMS.SetProgress(50);
@ -290,10 +290,11 @@ createFood
RMS.SetProgress(85);
log("Creating straggler trees...");
createStragglerTrees(
[oTree1, oTree2, oTree4, oTree3],
[avoidClasses(clForest, 7, clHill, 1, clPlayer, 9, clMetal, 6, clRock, 6), stayClasses(clLand, 7)]);
[avoidClasses(clForest, 7, clHill, 1, clPlayer, 9, clMetal, 6, clRock, 6), stayClasses(clLand, 7)],
clForest,
stragglerTrees);
setWaterWaviness(1.0);
setWaterType("ocean");

10
binaries/data/mods/public/maps/random/corinthian_isthmus.js
View file

@ -193,11 +193,12 @@ RMS.SetProgress(40);
createBumps(avoidClasses(clWater, 2, clPlayer, 20));
var [forestTrees, stragglerTrees] = getTreeCounts(500, 3000, 0.7);
createForests(
[tForestFloor, tForestFloor, tForestFloor, pForest, pForest],
avoidClasses(clPlayer, 20, clForest, 17, clWater, 2, clBaseResource, 3),
clForest
);
clForest,
forestTrees);
RMS.SetProgress(50);
@ -301,10 +302,11 @@ createFood
RMS.SetProgress(90);
log("Creating straggler trees...");
createStragglerTrees(
[oDatePalm, oSDatePalm, oCarob, oFanPalm, oPoplar, oCypress],
avoidClasses(clForest, 1, clWater, 2, clPlayer, 8, clBaseResource, 6, clMetal, 6, clRock, 6, clHill, 1));
avoidClasses(clForest, 1, clWater, 2, clPlayer, 8, clBaseResource, 6, clMetal, 6, clRock, 6, clHill, 1),
clForest,
stragglerTrees);
setSkySet("sunny");
setSunColor(0.917, 0.828, 0.734);

19
binaries/data/mods/public/maps/random/danubius.js
View file

@ -462,12 +462,12 @@ else
RMS.SetProgress(45);
log("Creating forests...");
var [forestTrees, stragglerTrees] = getTreeCounts(500, 3000, 0.7);
createForests(
[tForestFloor, tForestFloor, tForestFloor, pForest1, pForest2],
avoidClasses(clPlayer, 16, clForest, 17, clWater, 5, clHill, 2, clGauls, 5, clPath, 1),
clForest
);
clForest,
forestTrees);
RMS.SetProgress(50);
log("Creating grass patches...");
@ -657,14 +657,17 @@ createFood(
);
RMS.SetProgress(90);
log("Creating straggler trees...");
createStragglerTrees(
treeTypes,
avoidClasses(clForest, 2, clWater, 8, clPlayer, 16, clMetal, 4, clRock, 4, clFood, 1, clHill, 2, clGauls, 5, clPath, 5), clForest);
avoidClasses(clForest, 2, clWater, 8, clPlayer, 16, clMetal, 4, clRock, 4, clFood, 1, clHill, 2, clGauls, 5, clPath, 5),
clForest,
stragglerTrees);
log("Creating island straggler trees...");
g_numStragglerTrees *= 7;
createStragglerTrees(treeTypes, [stayClasses(clIsland, 4), avoidClasses(clMetal, 4, clRock, 4, clTower, 4, clOutpost, 4)], clForest);
createStragglerTrees(
treeTypes,
[stayClasses(clIsland, 4), avoidClasses(clMetal, 4, clRock, 4, clTower, 4, clOutpost, 4)],
clForest,
stragglerTrees * 7);
RMS.SetProgress(95);
log("Creating animals on islands...");

9
binaries/data/mods/public/maps/random/english_channel.js
View file

@ -242,12 +242,12 @@ RMS.SetProgress(30);
createHills([tCliff, tCliff, tHill], avoidClasses(clPlayer, 20, clHill, 15, clWater, 5), clHill, scaleByMapSize(1, 4) * numPlayers);
RMS.SetProgress(50);
var [forestTrees, stragglerTrees] = getTreeCounts(500, 3000, 0.7);
createForests(
[tGrass, tGrassDForest, tGrassDForest, pForestD, pForestD],
avoidClasses(clPlayer, 20, clForest, 17, clHill, 0, clWater, 6),
clForest,
1.0
);
forestTrees);
RMS.SetProgress(70);
log("Creating dirt patches...");
@ -354,10 +354,11 @@ createFood
[avoidClasses(clFood, 6), stayClasses(clWater, 4)]
);
log("Creating straggler trees...");
createStragglerTrees(
[oBeech, oPoplar, oApple],
avoidClasses(clWater, 1, clForest, 1, clHill, 1, clPlayer, 8, clMetal, 6, clRock, 6));
avoidClasses(clWater, 1, clForest, 1, clHill, 1, clPlayer, 8, clMetal, 6, clRock, 6),
clForest,
stragglerTrees);
setSkySet("cirrus");
setWaterColor(0.114, 0.192, 0.463);

48
binaries/data/mods/public/maps/random/extinct_volcano.js
View file

@ -54,11 +54,6 @@ const pForestP = [
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 clPlayer = createTileClass();
@ -215,15 +210,16 @@ createAreas(
RMS.SetProgress(35);
log("Creating forests...");
var [forestTrees, stragglerTrees] = getTreeCounts(1200, 3000, 0.7);
var types = [
[[tGrassB, tGrassA, pForestD], [tGrassB, pForestD]],
[[tGrassB, tGrassA, pForestP], [tGrassB, pForestP]]
];
var size = numForest / (scaleByMapSize(4, 12) * numPlayers);
var size = forestTrees / (scaleByMapSize(4, 12) * numPlayers);
var num = Math.floor(size / types.length);
for (let type of types)
createAreas(
new ClumpPlacer(numForest / num, 0.1, 0.1, 1),
new ClumpPlacer(forestTrees / num, 0.1, 0.1, 1),
[
new LayeredPainter(type, [2]),
paintClass(clForest)
@ -446,27 +442,21 @@ createFood(
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);
createStragglerTrees(
[oTree, oTree2, oTree3, oTree4, oBush],
[
stayClasses(clGrass, 1),
avoidClasses(
clWater, 5,
clForest, 1,
clHill, 1,
clPlayer, 0,
clMetal, 1,
clRock, 1)
],
clForest,
stragglerTrees);
RMS.SetProgress(90);
log("Creating straggler bushes...");
@ -486,7 +476,7 @@ createObjectGroupsDeprecated(
clMetal, 1,
clRock, 1)
],
numStragglers);
stragglerTrees);
RMS.SetProgress(95);
log("Creating rain drops...");

23
binaries/data/mods/public/maps/random/flood.js
View file

@ -279,17 +279,19 @@ createObjectGroupsDeprecated(
10 * numPlayers,
60);
var [forestTrees, stragglerTrees] = getTreeCounts(...rBiomeTreeCount(0.7));
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));
forestTrees);
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)]);
createStragglerTrees(
types,
[avoidClasses(clBaseResource, 2, clMetal, 6, clRock, 3, clMountain, 2, clPlayer, 25), stayClasses(clHill, 6)],
clForest,
stragglerTrees);
RMS.SetProgress(65);
log("Creating dirt patches...");
@ -338,8 +340,11 @@ createFood(
RMS.SetProgress(85);
log("Creating more straggeler trees...");
createStragglerTrees(types, avoidClasses(clWater, 5, clForest, 7, clMountain, 1, clPlayer, 30, clMetal, 6, clRock, 3));
createStragglerTrees(
types,
avoidClasses(clWater, 5, clForest, 7, clMountain, 1, clPlayer, 30, clMetal, 6, clRock, 3),
clForest,
stragglerTrees);
log("Creating decoration...");
var planetm = currentBiome() == "tropic" ? 8 : 1;
@ -361,12 +366,12 @@ createDecoration(
avoidClasses(clForest, 2, clPlayer, 20, clMountain, 5, clFood, 1, clBaseResource, 2));
log("Creating water forests...");
var [forestTrees, stragglerTrees] = getTreeCounts(...rBiomeTreeCount(0.1));
createForests(
[tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
avoidClasses(clPlayer, 30, clHill, 10, clFood, 5),
clForest,
0.1,
...rBiomeTreeCount(0.1));
forestTrees);
log("Creating small grass tufts...");
createObjectGroupsDeprecated(

19
binaries/data/mods/public/maps/random/fortress.js
View file

@ -201,26 +201,18 @@ 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 [forestTrees, stragglerTrees] = getTreeCounts(500, 2500, 0.7);
var types = [
[[tForestFloor, tGrass, pForestD], [tForestFloor, pForestD]],
[[tForestFloor, tGrass, pForestO], [tForestFloor, pForestO]],
[[tForestFloor, tGrass, pForestP], [tForestFloor, pForestP]]
];
var size = numForest / (scaleByMapSize(3,6) * numPlayers);
var size = forestTrees / (scaleByMapSize(3,6) * numPlayers);
var num = floor(size / types.length);
for (let type of types)
createAreas(
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), numForest / num, 0.5),
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), forestTrees / num, 0.5),
[
new LayeredPainter(type, [2]),
paintClass(clForest)
@ -314,10 +306,11 @@ createFood
RMS.SetProgress(90);
log("Creating straggler trees...");
createStragglerTrees(
[oOak, oBeech, oPine],
avoidClasses(clWater, 1, clForest, 1, clHill, 1, clPlayer, 1, clMetal, 6, clRock, 6));
avoidClasses(clWater, 1, clForest, 1, clHill, 1, clPlayer, 1, clMetal, 6, clRock, 6),
clForest,
stragglerTrees);
RMS.SetProgress(95);
setSkySet("sunny");

8
binaries/data/mods/public/maps/random/gear.js
View file

@ -271,12 +271,12 @@ if (randBool())
else
createMountains(tCliff, avoidClasses(clPlayer, 20, clHill, 15, clWater, 2), clHill, scaleByMapSize(1, 4) * numPlayers);
var [forestTrees, stragglerTrees] = getTreeCounts(...rBiomeTreeCount(1));
createForests(
[tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
avoidClasses(clPlayer, 20, clForest, 17, clHill, 0, clWater, 2),
clForest,
1,
...rBiomeTreeCount(1));
forestTrees);
RMS.SetProgress(50);
@ -377,6 +377,8 @@ createFood
createStragglerTrees(
[oTree1, oTree2, oTree4, oTree3],
avoidClasses(clWater, 5, clForest, 7, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6));
avoidClasses(clWater, 5, clForest, 7, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6),
clForest,
stragglerTrees);
ExportMap();

8
binaries/data/mods/public/maps/random/guadalquivir_river.js
View file

@ -199,11 +199,12 @@ paintTerrainBasedOnHeight(-8, 1, 2, tWater);
createBumps([avoidClasses(clPlayer, 20, clRiver, 1), stayClasses(clLand, 3)]);
var [forestTrees, stragglerTrees] = getTreeCounts(500, 3000, 0.7);
createForests(
[tGrass, tForestFloorP, tForestFloorC, pForestC, pForestP],
[avoidClasses(clPlayer, 20, clForest, 17, clHill, 0, clRiver, 1), stayClasses(clLand, 7)],
clForest,
1.0);
forestTrees);
RMS.SetProgress(50);
@ -314,10 +315,11 @@ createFood
RMS.SetProgress(85);
log("Creating straggler trees...");
createStragglerTrees(
[oPoplar, oCarob, oApple],
[avoidClasses(clForest, 1, clHill, 1, clPlayer, 9, clMetal, 6, clRock, 6, clRiver, 1), stayClasses(clLand, 7)]);
[avoidClasses(clForest, 1, clHill, 1, clPlayer, 9, clMetal, 6, clRock, 6, clRiver, 1), stayClasses(clLand, 7)],
clForest,
stragglerTrees);
setSkySet("cumulus");
setWaterColor(0.2,0.312,0.522);

11
binaries/data/mods/public/maps/random/gulf_of_bothnia.js
View file

@ -266,11 +266,12 @@ if (randBool())
else
createMountains(tCliff, avoidClasses(clPlayer, 20, clHill, 15, clWater, 0), clHill, scaleByMapSize(1, 4) * numPlayers);
var [forestTrees, stragglerTrees] = getTreeCounts(500, 3000, 0.7);
createForests(
[tPrimary, tForestFloor, tForestFloor, pForest, pForest],
avoidClasses(clPlayer, 20, clForest, 16, clHill, 0, clWater, 2),
clForest,
1);
forestTrees);
RMS.SetProgress(60);
@ -358,9 +359,11 @@ if (random_terrain != 3)
RMS.SetProgress(85);
log("Creating straggler trees...");
var types = [oPine];
createStragglerTrees(types, avoidClasses(clWater, 3, clForest, 1, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6));
createStragglerTrees(
[oPine],
avoidClasses(clWater, 3, clForest, 1, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6),
clForest,
stragglerTrees);
setSkySet("stormy");
setSunRotation(randFloat(0, TWO_PI));

32
binaries/data/mods/public/maps/random/hyrcanian_shores.js
View file

@ -194,24 +194,16 @@ createAreas(
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 mainland forests...");
var [forestTrees, stragglerTrees] = getTreeCounts(500, 2500, 0.7);
var types = [
[[tGrassDForest, tGrass, pForestD], [tGrassDForest, pForestD]]
];
var size = numForest * 1.3 / (scaleByMapSize(2,8) * numPlayers);
var size = forestTrees * 1.3 / (scaleByMapSize(2,8) * numPlayers);
var num = Math.floor(0.7 * size / types.length);
for (let type of types)
createAreas(
new ClumpPlacer(numForest / num, 0.1, 0.1, 1),
new ClumpPlacer(forestTrees / num, 0.1, 0.1, 1),
[
new LayeredPainter(type, [2]),
paintClass(clForest)
@ -224,11 +216,11 @@ log("Creating highland forests...");
var types = [
[[tGrassDForest, tGrass, pForestP], [tGrassDForest, pForestP]]
];
var size = numForest / (scaleByMapSize(2,8) * numPlayers);
var size = forestTrees / (scaleByMapSize(2,8) * numPlayers);
var num = floor(size / types.length);
for (let type of types)
createAreas(
new ClumpPlacer(numForest / num, 0.1, 0.1, 1),
new ClumpPlacer(forestTrees / num, 0.1, 0.1, 1),
[
new LayeredPainter(type, [2]),
paintClass(clForest)
@ -345,15 +337,11 @@ createObjectGroupsDeprecated(group, 0,
2 * numPlayers, 50
);
log("Creating straggler trees...");
var types = [oPoplar, oPalm, oApple];
var num = floor(numStragglers / types.length);
for (let type of types)
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(type, 1, 1, 0, 3)], true, clForest),
0,
avoidClasses(clWater, 1, clForest, 1, clHill, 1, clPlayer, 10, clMetal, 6, clRock, 6, clSea, 1, clHighlands, 25),
num);
createStragglerTrees(
[oPoplar, oPalm, oApple],
avoidClasses(clWater, 1, clForest, 1, clHill, 1, clPlayer, 10, clMetal, 6, clRock, 6, clSea, 1, clHighlands, 25),
clForest,
stragglerTrees);
log("Creating small grass tufts...");
group = new SimpleGroup(

15
binaries/data/mods/public/maps/random/island_stronghold.js
View file

@ -336,12 +336,12 @@ createMines(
clRock
);
var [forestTrees, stragglerTrees] = getTreeCounts(...rBiomeTreeCount(1));
createForests(
[tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
[avoidClasses(clPlayer, 10, clForest, 20, clHill, 10, clBaseResource, 5, clRock, 6, clMetal, 6), stayClasses(clLand, 3)],
clForest,
1,
...rBiomeTreeCount(1));
forestTrees);
log("Creating hills...");
createAreas(
@ -359,10 +359,13 @@ for (let i = 0; i < 3; ++i)
globalSmoothHeightmap();
createStragglerTrees(
[oTree1, oTree2, oTree4, oTree3],
[avoidClasses(clForest, 10, clPlayer, 20, clMetal, 6, clRock, 6, clHill, 1),
stayClasses(clLand, 4)]
);
[oTree1, oTree2, oTree4, oTree3],
[
avoidClasses(clForest, 10, clPlayer, 20, clMetal, 6, clRock, 6, clHill, 1),
stayClasses(clLand, 4)
],
clForest,
stragglerTrees);
createFood(
[

42
binaries/data/mods/public/maps/random/islands.js
View file

@ -287,30 +287,8 @@ createAreas(
[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 [forestTrees, stragglerTrees] = getTreeCounts(...rBiomeTreeCount(1));
var types = [
[[tForestFloor2, tMainTerrain, pForest1], [tForestFloor2, pForest1]],
[[tForestFloor1, tMainTerrain, pForest2], [tForestFloor1, pForest2]]
@ -318,11 +296,11 @@ var types = [
if (currentBiome() != "savanna")
{
var size = numForest / (scaleByMapSize(3,6) * numPlayers);
var size = forestTrees / (scaleByMapSize(3,6) * numPlayers);
var num = floor(size / types.length);
for (let type of types)
createAreas(
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), numForest / (num * Math.floor(scaleByMapSize(2, 5))), 0.5),
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), forestTrees / (num * Math.floor(scaleByMapSize(2, 5))), 0.5),
[
new LayeredPainter(type, [2]),
paintClass(clForest)
@ -445,15 +423,11 @@ createObjectGroupsDeprecated(group, 0,
RMS.SetProgress(85);
log("Creating straggler trees...");
var types = [oTree1, oTree2, oTree4, oTree3];
var num = floor(numStragglers / types.length);
for (let type of types)
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(type, 1, 1, 0, 3)], true, clForest),
0,
[avoidClasses(clForest, 1, clHill, 1, clPlayer, 0, clMetal, 6, clRock, 6), stayClasses(clLand, 6)],
num);
createStragglerTrees(
[oTree1, oTree2, oTree4, oTree3],
[avoidClasses(clForest, 1, clHill, 1, clPlayer, 0, clMetal, 6, clRock, 6), stayClasses(clLand, 6)],
clForest,
stragglerTrees);
var planetm = 1;
if (currentBiome() == "tropic")

28
binaries/data/mods/public/maps/random/kerala.js
View file

@ -190,28 +190,20 @@ createAreas(
[avoidClasses(clPlayer, 20, clHill, 5, clWater, 2, clBaseResource, 2), stayClasses(clMountains, 0)],
scaleByMapSize(5, 40) * numPlayers);
// calculate desired number of trees for map (based on size)
var MIN_TREES = 1000;
var MAX_TREES = 6000;
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 [forestTrees, stragglerTrees] = getTreeCounts(1000, 6000, 0.7);
var types = [
[[tGrass, tGrass, tGrass, tGrass, pForestD], [tGrass, tGrass, tGrass, pForestD]],
[[tGrass, tGrass, tGrass, tGrass, pForestP], [tGrass, tGrass, tGrass, pForestP]]
];
var size = numForest / (scaleByMapSize(3,6) * numPlayers);
var size = forestTrees / (scaleByMapSize(3,6) * numPlayers);
var num = floor(size / types.length);
for (let type of types)
createAreas(
new ChainPlacer(
1,
Math.floor(scaleByMapSize(3, 5)),
numForest / (num * Math.floor(scaleByMapSize(2, 4))),
forestTrees / (num * Math.floor(scaleByMapSize(2, 4))),
0.5),
[
new LayeredPainter(type, [2]),
@ -319,15 +311,11 @@ createObjectGroupsDeprecated(group, 0,
RMS.SetProgress(95);
log("Creating straggler trees...");
var types = [oTree, oPalm];
var num = floor(numStragglers / types.length);
for (let type of types)
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(type, 1, 1, 0, 3)], true, clForest),
0,
avoidClasses(clWater, 5, clForest, 1, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6),
num);
createStragglerTrees(
[oTree, oPalm],
avoidClasses(clWater, 5, clForest, 1, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6),
clForest,
stragglerTrees);
log("Creating deer...");
group = new SimpleGroup(

8
binaries/data/mods/public/maps/random/lake.js
View file

@ -185,12 +185,12 @@ if (randBool())
else
createMountains(tCliff, avoidClasses(clPlayer, 20, clHill, 15, clWater, 2), clHill, scaleByMapSize(1, 4) * numPlayers);
var [forestTrees, stragglerTrees] = getTreeCounts(...rBiomeTreeCount(1));
createForests(
[tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
avoidClasses(clPlayer, 20, clForest, 17, clHill, 0, clWater, 2),
clForest,
1,
...rBiomeTreeCount(1));
forestTrees);
RMS.SetProgress(50);
@ -296,7 +296,9 @@ RMS.SetProgress(85);
createStragglerTrees(
[oTree1, oTree2, oTree4, oTree3],
avoidClasses(clWater, 5, clForest, 7, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6));
avoidClasses(clWater, 5, clForest, 7, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6),
clForest,
stragglerTrees);
setWaterWaviness(4.0);
setWaterType("lake");

15
binaries/data/mods/public/maps/random/latium.js
View file

@ -440,15 +440,12 @@ createObjectGroups(group, 0,
);
RMS.SetProgress(60);
log("Creating straggler trees...");
for (let tree of [oCarob, oBeech, oLombardyPoplar, oLombardyPoplar, oPine])
{
group = new SimpleGroup([new SimpleObject(tree, 1,1, 0,1)], true, clForest);
createObjectGroupsDeprecated(group, 0,
avoidClasses(clWater, 5, clCliff, 4, clForest, 2, clPlayer, 15, clMetal, 6, clRock, 6),
scaleByMapSize(2, 38), 50
);
}
createStragglerTrees(
[oCarob, oBeech, oLombardyPoplar, oLombardyPoplar, oPine],
avoidClasses(clWater, 5, clCliff, 4, clForest, 2, clPlayer, 15, clMetal, 6, clRock, 6),
clForest,
scaleByMapSize(10, 190));
RMS.SetProgress(70);
log("Creating straggler cypresses...");

49
binaries/data/mods/public/maps/random/lorraine_plain.js
View file

@ -258,35 +258,12 @@ createAreas(
);
RMS.SetProgress(55);
// 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 = [
[[tGrassDForest, tGrass, pForestB], [tGrassDForest, pForestB]],
[[tGrassPForest, tGrass, pForestO], [tGrassPForest, pForestO]]
];
var size = numForest / (scaleByMapSize(3, 6) * numPlayers);
var num = Math.floor(size / types.length);
for (let type of types)
createAreas(
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), numForest / num, 0.5),
[
new LayeredPainter(type, [2]),
paintClass(clForest)
],
avoidClasses(
clPlayer, 15,
clWater, 3,
clForest, 16,
clHill, 1),
num);
var [forestTrees, stragglerTrees] = getTreeCounts(500, 2500, 0.7);
createForests(
[tGrass, tGrassDForest, tGrassPForest, pForestB, pForestO],
avoidClasses(clPlayer, 15, clWater, 3, clForest, 16, clHill, 1),
clForest,
forestTrees);
RMS.SetProgress(70);
log("Creating dirt patches...");
@ -386,15 +363,11 @@ createObjectGroupsDeprecated(group, 0,
randIntInclusive(1, 4) * numPlayers + 2, 50
);
log("Creating straggler trees...");
var types = [oOak, oBeech];
var num = floor(numStragglers / types.length);
for (let type of types)
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(type, 1, 1, 0, 3)], true, clForest),
0,
avoidClasses(clWater, 1, clForest, 7, clHill, 1, clPlayer, 5, clMetal, 6, clRock, 6),
num);
createStragglerTrees(
[oOak, oBeech],
avoidClasses(clWater, 1, clForest, 7, clHill, 1, clPlayer, 5, clMetal, 6, clRock, 6),
clForest,
stragglerTrees);
log("Creating small grass tufts...");
group = new SimpleGroup(

10
binaries/data/mods/public/maps/random/mainland.js
View file

@ -139,12 +139,12 @@ if (randBool())
else
createMountains(tCliff, avoidClasses(clPlayer, 20, clHill, 15), clHill, scaleByMapSize(3, 15));
var [forestTrees, stragglerTrees] = getTreeCounts(...rBiomeTreeCount(1));
createForests(
[tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
avoidClasses(clPlayer, 20, clForest, 18, clHill, 0),
clForest,
1,
...rBiomeTreeCount(1));
forestTrees);
RMS.SetProgress(50);
@ -237,6 +237,10 @@ createFood
RMS.SetProgress(85);
createStragglerTrees([oTree1, oTree2, oTree4, oTree3]);
createStragglerTrees(
[oTree1, oTree2, oTree4, oTree3],
avoidClasses(clForest, 8, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6),
clForest,
stragglerTrees);
ExportMap();

44
binaries/data/mods/public/maps/random/migration.js
View file

@ -240,43 +240,20 @@ createAreas(
);
RMS.SetProgress(34);
// 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 [forestTrees, stragglerTrees] = getTreeCounts(...rBiomeTreeCount(1));
var types = [
[[tForestFloor2, tMainTerrain, pForest1], [tForestFloor2, pForest1]],
[[tForestFloor1, tMainTerrain, pForest2], [tForestFloor1, pForest2]]
];
var size = numForest / (scaleByMapSize(2,8) * numPlayers) *
var size = forestTrees / (scaleByMapSize(2,8) * numPlayers) *
(currentBiome() == "savanna" ? 2 : 1);
var num = floor(size / types.length);
for (let type of types)
createAreas(
new ClumpPlacer(numForest / num, 0.1, 0.1, 1),
new ClumpPlacer(forestTrees / num, 0.1, 0.1, 1),
[
new LayeredPainter(type, [2]),
paintClass(clForest)
@ -406,15 +383,12 @@ createObjectGroupsDeprecated(
);
RMS.SetProgress(82);
log("Creating straggler trees...");
var types = [oTree1, oTree2, oTree4, oTree3];
var num = floor(numStragglers / types.length);
for (let type of types)
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(type, 1, 1, 0, 3)], true, clForest),
0,
[avoidClasses(clForest, 1, clHill, 1, clPlayer, 9, clMetal, 6, clRock, 6), stayClasses(clLand, 9)],
num);
createStragglerTrees(
[oTree1, oTree2, oTree4, oTree3],
[avoidClasses(clForest, 1, clHill, 1, clPlayer, 9, clMetal, 6, clRock, 6), stayClasses(clLand, 9)],
clForest,
stragglerTrees);
RMS.SetProgress(86);
var planetm = currentBiome() == "tropic" ? 8 : 1;

26
binaries/data/mods/public/maps/random/neareastern_badlands.js
View file

@ -300,18 +300,10 @@ createAreas(
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 [forestTrees, stragglerTrees] = getTreeCounts(500, 2500, 0.5);
var num = scaleByMapSize(10,30);
placer = new ClumpPlacer(numForest / num, 0.15, 0.1, 0.5);
placer = new ClumpPlacer(forestTrees / num, 0.15, 0.1, 0.5);
painter = new TerrainPainter([tSand, pForest]);
createAreas(placer, [painter, paintClass(clForest)],
avoidClasses(clPlayer, 1, clForest, 10, clHill1, 1),
@ -364,15 +356,11 @@ createObjectGroupsDeprecated(group, 0,
);
RMS.SetProgress(85);
log("Creating straggler trees...");
var types = [oDatePalm, oSDatePalm];
var num = floor(numStragglers / types.length);
for (let type of types)
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(type, 1, 1, 0, 0)], true),
0,
avoidClasses(clForest, 0, clHill1, 1, clPlayer, 4, clMetal, 6, clRock, 6),
num);
createStragglerTrees(
[oDatePalm, oSDatePalm],
avoidClasses(clForest, 0, clHill1, 1, clPlayer, 4, clMetal, 6, clRock, 6),
clForest,
stragglerTrees);
RMS.SetProgress(90);
log("Creating bushes...");

28
binaries/data/mods/public/maps/random/northern_lights.js
View file

@ -190,27 +190,19 @@ createAreas(
scaleByMapSize(1, 4) * numPlayers
);
// calculate desired number of trees for map (based on size)
var MIN_TREES = 100;
var MAX_TREES = 625;
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 [forestTrees, stragglerTrees] = getTreeCounts(100, 625, 0.7);
var types = [
[[tSnowA, tSnowA, tSnowA, tSnowA, pForestD], [tSnowA, tSnowA, tSnowA, pForestD]],
[[tSnowA, tSnowA, tSnowA, tSnowA, pForestS], [tSnowA, tSnowA, tSnowA, pForestS]]
];
var size = numForest / (scaleByMapSize(3,6) * numPlayers);
var size = forestTrees / (scaleByMapSize(3,6) * numPlayers);
var num = floor(size / types.length);
for (let type of types)
createAreas(
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), numForest / (num * Math.floor(scaleByMapSize(2, 4))), 1),
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), forestTrees / (num * Math.floor(scaleByMapSize(2, 4))), 1),
[
new LayeredPainter(type, [2]),
paintClass(clForest)
@ -280,15 +272,11 @@ createObjectGroupsDeprecated(group, 0,
);
RMS.SetProgress(95);
log("Creating straggler trees...");
var types = [oPine];
var num = floor(numStragglers / types.length);
for (let type of types)
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(type, 1, 1, 0, 3)], true, clForest),
0,
avoidClasses(clWater, 5, clForest, 1, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6),
num);
createStragglerTrees(
[oPine],
avoidClasses(clWater, 5, clForest, 1, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6),
clForest,
stragglerTrees);
log("Creating deer...");
group = new SimpleGroup(

36
binaries/data/mods/public/maps/random/persian_highlands.js
View file

@ -218,21 +218,13 @@ for (let i = 0; i < scaleByMapSize(20, 80); ++i)
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 [forestTrees, stragglerTrees] = getTreeCounts(500, 2500, 0.7);
var types = [
[[tDirtMain, tForestFloor, pForestO], [tForestFloor, pForestO]],
[[tDirtMain, tForestFloor, pForestO], [tForestFloor, pForestO]]
];
var size = numForest / (scaleByMapSize(3,6) * numPlayers);
var size = forestTrees / (scaleByMapSize(3,6) * numPlayers);
var num = floor(size / types.length);
for (let type of types)
createAreas(
@ -365,25 +357,11 @@ createObjectGroupsDeprecated(group, 0,
RMS.SetProgress(90);
log("Creating straggler trees...");
var types = [oOak];
var num = floor(numStragglers / types.length);
for (let type of types)
createObjectGroupsDeprecated(
new SimpleGroup(
[new SimpleObject(type, 1, 1, 0, 3)],
true,
clForest),
0,
avoidClasses(
clForest, 1,
clHill, 1,
clPlayer, 1,
clBaseResource, 6,
clMetal, 6,
clRock, 6,
clCP, 2),
num);
createStragglerTrees(
[oOak],
avoidClasses(clForest, 1, clHill, 1, clPlayer, 1, clBaseResource, 6, clMetal, 6, clRock, 6, clCP, 2),
clForest,
stragglerTrees);
setSunColor(1.0, 0.796, 0.374);
setSunElevation(PI / 6);

24
binaries/data/mods/public/maps/random/phoenician_levant.js
View file

@ -180,19 +180,11 @@ createAreas(
avoidClasses(clPlayer, 20, clForest, 1, clHill, 15, clWater, 0),
scaleByMapSize(1, 4) * numPlayers * 3);
// 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 [forestTrees, stragglerTrees] = getTreeCounts(500, 2500, 0.5);
var num = scaleByMapSize(10,42);
createAreas(
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), numForest / (num * Math.floor(scaleByMapSize(2, 5))), 0.5),
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), forestTrees / (num * Math.floor(scaleByMapSize(2, 5))), 0.5),
[
new TerrainPainter([tForestFloor, pForest]),
paintClass(clForest)
@ -347,18 +339,16 @@ createObjectGroupsDeprecated(group, 0,
);
RMS.SetProgress(90);
log("Creating straggler trees...");
var types = [oDatePalm, oSDatePalm, oCarob, oFanPalm, oPoplar, oCypress];
var stragglerTrees = [
[1, avoidClasses(clForest, 0, clWater, 1, clPlayer, 8, clMetal, 6, clHill, 1)],
[3, stayClasses(clIsland, 9)]
];
for (let [amount, constraint] of stragglerTrees)
{
let num = amount * Math.floor(numStragglers / types.length);
for (let type of types)
createObjectGroupsDeprecated(new SimpleGroup([new SimpleObject(type, 1, 1, 0, 0)], true), 0, constraint, num);
}
createStragglerTrees(
[oDatePalm, oSDatePalm, oCarob, oFanPalm, oPoplar, oCypress],
constraint,
clForest,
amount * stragglerTrees);
setSkySet("sunny");
setSunColor(0.917, 0.828, 0.734);

31
binaries/data/mods/public/maps/random/rhine_marshlands.js
View file

@ -163,25 +163,17 @@ createAreas(
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 [forestTrees, stragglerTrees] = getTreeCounts(500, 2500, 0.7);
var types = [
[[tForestFloor, tGrass, pForestD], [tForestFloor, pForestD]],
[[tForestFloor, tGrass, pForestP], [tForestFloor, pForestP]]
];
var size = numForest / (scaleByMapSize(3,6) * numPlayers);
var size = forestTrees / (scaleByMapSize(3,6) * numPlayers);
var num = floor(size / types.length);
for (let type of types)
createAreas(
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), numForest / (num * Math.floor(scaleByMapSize(2, 4))), 1),
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), forestTrees / (num * Math.floor(scaleByMapSize(2, 4))), 1),
[
new LayeredPainter(type, [2]),
paintClass(clForest)
@ -304,18 +296,11 @@ createObjectGroupsDeprecated(group, 0,
RMS.SetProgress(80);
log("Creating straggler trees...");
var types = [oOak, oBeech];
var num = floor(numStragglers / types.length);
for (let type of types)
createObjectGroupsDeprecated(
new SimpleGroup(
[new SimpleObject(type, 1, 1, 0, 3)],
true,
clForest),
0,
avoidClasses(clForest, 1, clHill, 1, clPlayer, 13, clMetal, 6, clRock, 6, clWater, 0),
num);
createStragglerTrees(
[oOak, oBeech],
avoidClasses(clForest, 1, clHill, 1, clPlayer, 13, clMetal, 6, clRock, 6, clWater, 0),
clForest,
stragglerTrees);
RMS.SetProgress(85);

41
binaries/data/mods/public/maps/random/river_archipelago.js
View file

@ -252,24 +252,20 @@ createBumps(avoidClasses(clPlayer, 8, clWater, 2), scaleByMapSize(20, 150), 2, 8
RMS.SetProgress(50);
log("Creating forests...");
var P_FOREST = 0.7;
var totalTrees = scaleByMapSize(1000, 4000);
var numForest = totalTrees * P_FOREST;
var numStragglers = totalTrees * (1.0 - P_FOREST);
var [forestTrees, stragglerTrees] = getTreeCounts(1000, 4000, 0.7);
var types = [
[[tGrass, tGrass, tGrass, tGrass, pForestD], [tGrass, tGrass, tGrass, pForestD]],
[[tGrass, tGrass, tGrass, tGrass, pForestP1], [tGrass, tGrass, tGrass, pForestP1]],
[[tGrass, tGrass, tGrass, tGrass, pForestP2], [tGrass, tGrass, tGrass, pForestP2]]
];
var size = numForest / (scaleByMapSize(3, 6) * numPlayers);
var size = forestTrees / (scaleByMapSize(3, 6) * numPlayers);
var num = Math.floor(size / types.length);
for (let type of types)
createAreas(
new ChainPlacer(
1,
Math.floor(scaleByMapSize(3, 5)),
numForest / (num * Math.floor(scaleByMapSize(2, 4))),
forestTrees / (num * Math.floor(scaleByMapSize(2, 4))),
0.5),
[
new LayeredPainter(type, [2]),
@ -283,23 +279,20 @@ for (let type of types)
clWater, 2),
num);
log("Creating straggler trees...");
var types = [oTree, oPalm1, oPalm2];
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,
avoidClasses(
clWater, 5,
clForest, 1,
clHill, 1,
clPlayer, 8,
clBaseResource, 4,
clGaia, 1,
clMetal, 4,
clRock, 4),
num);
createStragglerTrees(
[oTree, oPalm1, oPalm2],
avoidClasses(
clWater, 5,
clForest, 1,
clHill, 1,
clPlayer, 8,
clBaseResource, 4,
clGaia, 1,
clMetal, 4,
clRock, 4),
clForest,
stragglerTrees);
RMS.SetProgress(60);
log("Creating grass patches...");

8
binaries/data/mods/public/maps/random/rivers.js
View file

@ -302,12 +302,12 @@ if (randBool())
else
createMountains(tCliff, avoidClasses(clPlayer, 20, clHill, 15, clWater, 2), clHill, scaleByMapSize(3, 15));
var [forestTrees, stragglerTrees] = getTreeCounts(...rBiomeTreeCount(1));
createForests(
[tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
avoidClasses(clPlayer, 20, clForest, 17, clHill, 0, clWater, 2),
clForest,
1,
...rBiomeTreeCount(1));
forestTrees);
RMS.SetProgress(50);
@ -426,7 +426,9 @@ RMS.SetProgress(85);
createStragglerTrees(
[oTree1, oTree2, oTree4, oTree3],
avoidClasses(clWater, 5, clForest, 7, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6));
avoidClasses(clWater, 5, clForest, 7, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6),
clForest,
stragglerTrees);
setWaterWaviness(3.0);
setWaterType("lake");

60
binaries/data/mods/public/maps/random/rmgen/gaia_entities.js
View file

@ -2,6 +2,66 @@
* @file These functions are often used to place gaia entities, like forests, mines, animals or decorative bushes.
*/
/**
* Returns the number of trees in forests and straggler trees.
*/
function getTreeCounts(minTrees, maxTrees, forestRatio)
{
return [forestRatio, 1 - forestRatio].map(p => p * scaleByMapSize(minTrees, maxTrees));
}
/**
* Places uniformly sized forests at random locations.
* Generates two variants of forests from the given terrain textures and tree templates.
* The forest border has less trees than the inside.
*/
function createForests(terrainSet, constraint, tileClass, treeCount)
{
if (!treeCount)
return;
// Construct different forest types from the terrain textures and template names.
let [mainTerrain, terrainForestFloor1, terrainForestFloor2, terrainForestTree1, terrainForestTree2] = terrainSet;
// The painter will pick a random Terrain for each part of the forest.
let forestVariants = [
{
"borderTerrains": [terrainForestFloor2, mainTerrain, terrainForestTree1],
"interiorTerrains": [terrainForestFloor2, terrainForestTree1]
},
{
"borderTerrains": [terrainForestFloor1, mainTerrain, terrainForestTree2],
"interiorTerrains": [terrainForestFloor1, terrainForestTree2]
}
];
log("Creating forests...");
let numberOfForests = Math.floor(treeCount / (scaleByMapSize(3, 6) * getNumPlayers() * forestVariants.length));
for (let forestVariant of forestVariants)
createAreas(
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), treeCount / numberOfForests, 0.5),
[
new LayeredPainter([forestVariant.borderTerrains, forestVariant.interiorTerrains], [2]),
paintClass(tileClass)
],
constraint,
numberOfForests);
}
/**
* Places the given amount of Entities at random places meeting the given Constraint, chosing a different template for each.
*/
function createStragglerTrees(templateNames, constraint, tileClass, treeCount)
{
log("Creating straggler trees...");
for (let templateName of templateNames)
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(templateName, 1, 1, 0, 3)], true, tileClass),
0,
constraint,
Math.floor(treeCount / templateNames.length));
}
/**
* Places a SimpleGroup consisting of the given number of the given Objects
* at random locations that meet the given Constraint.

60
binaries/data/mods/public/maps/random/rmgen/utilityfunctions.js
View file

@ -1,60 +0,0 @@
var g_numStragglerTrees = 0;
function createForests(terrainset, constraint, tileclass, numMultiplier = 1, minTrees = 500, maxTrees = 3000, forestProbability = 0.7)
{
log("Creating forests...");
tileclass = tileclass || clForest;
constraint = constraint || avoidClasses(clPlayer, 20, clForest, 17, clHill, 0);
var [tM, tFF1, tFF2, tF1, tF2] = terrainset;
var totalTrees = scaleByMapSize(minTrees, maxTrees);
var numForest = totalTrees * forestProbability;
g_numStragglerTrees = totalTrees * (1.0 - forestProbability);
if (!forestProbability)
return;
log("Creating forests...");
let types = [
[[tFF2, tM, tF1], [tFF2, tF1]],
[[tFF1, tM, tF2], [tFF1, tF2]]
];
let num = Math.floor(numForest / (scaleByMapSize(3,6) * numPlayers) / types.length);
for (let type of types)
createAreas(
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), numForest / num, 0.5),
[
new LayeredPainter(type, [2]),
paintClass(tileclass)
],
constraint,
num
);
}
function createStragglerTrees(types, constraint, tileclass)
{
log("Creating straggler trees...");
constraint = constraint !== undefined ?
constraint :
avoidClasses(clForest, 8, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6);
tileclass = tileclass !== undefined ? tileclass : clForest;
var num = floor(g_numStragglerTrees / types.length);
for (var i = 0; i < types.length; ++i)
{
let group = new SimpleGroup(
[new SimpleObject(types[i], 1,1, 0,3)],
true, tileclass
);
createObjectGroupsDeprecated(group, 0,
constraint,
num
);
}
}

13
binaries/data/mods/public/maps/random/sahel.js
View file

@ -246,16 +246,11 @@ createObjectGroupsDeprecated(group, 0,
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,
createStragglerTrees(
[oBaobab],
avoidClasses(clForest, 1, clPlayer, 20, clMetal, 6, clRock, 7, clWater, 1),
num
);
clForest,
scaleByMapSize(70, 500));
log("Creating large grass tufts...");
group = new SimpleGroup(

28
binaries/data/mods/public/maps/random/sahel_watering_holes.js
View file

@ -251,25 +251,17 @@ createAreas(
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 [forestTrees, stragglerTrees] = getTreeCounts(160, 900, 0.02);
var types = [
[[tForestFloor, tGrass, pForest], [tForestFloor, pForest]]
];
var size = numForest / (0.5 * scaleByMapSize(2,8) * numPlayers);
var size = forestTrees / (0.5 * scaleByMapSize(2,8) * numPlayers);
var num = floor(size / types.length);
for (let type of types)
createAreas(
new ClumpPlacer(numForest / num, 0.1, 0.1, 1),
new ClumpPlacer(forestTrees / num, 0.1, 0.1, 1),
[
new LayeredPainter(type, [2]),
paintClass(clForest)
@ -422,15 +414,11 @@ createObjectGroupsDeprecated(group, 0,
RMS.SetProgress(85);
log("Creating straggler trees...");
var types = [oBaobab, oBaobab, oBaobab, oFig];
var num = floor(numStragglers / types.length);
for (let type of types)
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(type, 1,1, 0,3)], true, clForest),
0,
avoidClasses(clWater, 5, clForest, 1, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6),
num);
createStragglerTrees(
[oBaobab, oBaobab, oBaobab, oFig],
avoidClasses(clWater, 5, clForest, 1, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6),
clForest,
stragglerTrees);
var planetm = 4;
log("Creating small grass tufts...");

42
binaries/data/mods/public/maps/random/snowflake_searocks.js
View file

@ -339,40 +339,18 @@ for (let ix = 0; ix < mapSize; ++ix)
}
}
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 [forestTrees, stragglerTrees] = getTreeCounts(...rBiomeTreeCount(1));
var types = [
[[tForestFloor2, tMainTerrain, pForest1], [tForestFloor2, pForest1]],
[[tForestFloor1, tMainTerrain, pForest2], [tForestFloor1, pForest2]]
];
var size = numForest / (scaleByMapSize(2, 8) * numPlayers) * (currentBiome() == "savanna" ? 2 : 1);
var size = forestTrees / (scaleByMapSize(2, 8) * numPlayers) * (currentBiome() == "savanna" ? 2 : 1);
var num = floor(size / types.length);
for (let type of types)
createAreas(
new ClumpPlacer(numForest / num, 0.1, 0.1, 1),
new ClumpPlacer(forestTrees / num, 0.1, 0.1, 1),
[
new LayeredPainter(type, [2]),
paintClass(clForest)
@ -479,15 +457,11 @@ createObjectGroupsDeprecated(group, 0,
);
RMS.SetProgress(85);
log("Creating straggler trees...");
var types = [oTree1, oTree2, oTree4, oTree3];
var num = floor(numStragglers / types.length);
for (let type of types)
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(type, 1, 1, 0, 3)], true, clForest),
0,
[avoidClasses(clForest, 1, clHill, 1, clPlayer, 9, clMetal, 6, clRock, 6), stayClasses(clLand, 4)],
num);
createStragglerTrees(
[oTree1, oTree2, oTree4, oTree3],
[avoidClasses(clForest, 1, clHill, 1, clPlayer, 9, clMetal, 6, clRock, 6), stayClasses(clLand, 4)],
clForest,
stragglerTrees);
var planetm = 1;
if (currentBiome() == "tropic")

9
binaries/data/mods/public/maps/random/survivalofthefittest.js
View file

@ -163,12 +163,12 @@ RMS.SetProgress(25);
createBumps(stayClasses(clLand, 5));
var [forestTrees, stragglerTrees] = getTreeCounts(...rBiomeTreeCount(1));
createForests(
[tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
[avoidClasses(clPlayer, 20, clForest, 5, clHill, 0, clBaseResource,2, clWomen, 5), stayClasses(clLand, 4)],
clForest,
1,
...rBiomeTreeCount(1));
forestTrees);
RMS.SetProgress(30);
if (randBool())
@ -237,9 +237,10 @@ createDecoration(
[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)]);
[avoidClasses(clForest, 7, clHill, 1, clPlayer, 9), stayClasses(clLand, 7)],
clForest,
stragglerTrees);
ExportMap();

42
binaries/data/mods/public/maps/random/syria.js
View file

@ -155,28 +155,20 @@ createAreas(
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 [forestTrees, stragglerTrees] = getTreeCounts(400, 2000, 0.7);
var types = [
[[tMainDirt, tForestFloor2, pForestP], [tForestFloor2, pForestP]],
[[tMainDirt, tForestFloor1, pForestT], [tForestFloor1, pForestT]]
];
var size = numForest / (scaleByMapSize(3,6) * numPlayers);
var size = forestTrees / (scaleByMapSize(3,6) * numPlayers);
var num = floor(size / types.length);
for (let type of types)
createAreas(
new ChainPlacer(
1,
Math.floor(scaleByMapSize(3, 5)),
numForest / (num * Math.floor(scaleByMapSize(2, 4))),
forestTrees / (num * Math.floor(scaleByMapSize(2, 4))),
0.5),
[
new LayeredPainter(type, [2]),
@ -280,25 +272,17 @@ createObjectGroupsDeprecated(group, 0,
);
RMS.SetProgress(85);
log("Creating straggler trees...");
var types = [oPalm, oTamarix, oPine];
var num = floor(numStragglers / types.length);
for (let type of types)
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(type, 1, 1, 0, 3)], true, clForest),
0,
avoidClasses(clForest, 1, clHill, 1, clPlayer, 1, clMetal, 6, clRock, 6),
num);
createStragglerTrees(
[oPalm, oTamarix, oPine],
avoidClasses(clForest, 1, clHill, 1, clPlayer, 1, clMetal, 6, clRock, 6),
clForest,
stragglerTrees);
log("Creating straggler trees...");
var types = [oPalm, oTamarix, oPine];
var num = floor(numStragglers / types.length);
for (let type of types)
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(type, 1,1, 0,3)], true, clForest),
0,
[avoidClasses(clForest, 1, clHill, 1, clPlayer, 1, clMetal, 6, clRock, 6), stayClasses(clGrass, 3)],
num);
createStragglerTrees(
[oPalm, oTamarix, oPine],
[avoidClasses(clForest, 1, clHill, 1, clPlayer, 1, clMetal, 6, clRock, 6), stayClasses(clGrass, 3)],
clForest,
stragglerTrees);
setSkySet("sunny");
setSunElevation(PI / 8);

53
binaries/data/mods/public/maps/random/the_nile.js
View file

@ -256,19 +256,11 @@ createObjectGroupsByAreasDeprecated(
waterAreas = [];
// calculate desired number of trees for map (based on size)
const MIN_TREES = 700;
const MAX_TREES = 3500;
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 [forestTrees, stragglerTrees] = getTreeCounts(700, 3500, 0.5);
var num = scaleByMapSize(10,30);
createAreas(
new ClumpPlacer(numForest / num, 0.15, 0.1, 0.5),
new ClumpPlacer(forestTrees / num, 0.15, 0.1, 0.5),
[
new TerrainPainter([pForest, tForestFloor]),
paintClass(clForest)
@ -411,34 +403,23 @@ createObjectGroupsDeprecated(group, 0,
RMS.SetProgress(90);
log("Creating straggler trees...");
var types = [oDatePalm, oSDatePalm];
var num = floor(0.5 * numStragglers / types.length);
for (let type of types)
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(type, 1, 1, 0, 0)], true),
0,
avoidClasses(clForest, 0, clWater, 1, clPlayer, 20, clMetal, 6, clDesert, 1, clTreasure, 2, clPond, 1),
num);
createStragglerTrees(
[oDatePalm, oSDatePalm],
avoidClasses(clForest, 0, clWater, 1, clPlayer, 20, clMetal, 6, clDesert, 1, clTreasure, 2, clPond, 1),
clForest,
stragglerTrees / 2);
var types = [oDatePalm, oSDatePalm];
var num = floor(0.1 * numStragglers / types.length);
for (let type of types)
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(type, 1,1, 0,0)], true),
0,
avoidClasses(clForest, 0, clWater, 1, clPlayer, 20, clMetal, 6, clTreasure, 2),
num);
createStragglerTrees(
[oDatePalm, oSDatePalm],
avoidClasses(clForest, 0, clWater, 1, clPlayer, 20, clMetal, 6, clTreasure, 2),
clForest,
stragglerTrees / 10);
log("Creating straggler trees...");
var types = [oDatePalm, oSDatePalm];
var num = floor(numStragglers / types.length);
for (let type of types)
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(type, 1, 1, 0, 0)], true),
0,
borderClasses(clPond, 1, 4),
num);
createStragglerTrees(
[oDatePalm, oSDatePalm],
borderClasses(clPond, 1, 4),
clForest,
stragglerTrees);
log("Creating obelisks");
group = new SimpleGroup(

28
binaries/data/mods/public/maps/random/volcanic_lands.js
View file

@ -119,25 +119,17 @@ createAreas(
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 [forestTrees, stragglerTrees] = getTreeCounts(200, 1250, 0.7);
var types = [
[[tGrassB, tGrassA, pForestD], [tGrassB, pForestD]],
[[tGrassB, tGrassA, pForestP], [tGrassB, pForestP]]
];
var size = numForest / (scaleByMapSize(2,8) * numPlayers);
var size = forestTrees / (scaleByMapSize(2,8) * numPlayers);
var num = floor(size / types.length);
for (let type of types)
createAreas(
new ClumpPlacer(numForest / num, 0.1, 0.1, 1),
new ClumpPlacer(forestTrees / num, 0.1, 0.1, 1),
[
new LayeredPainter(type, [2]),
paintClass(clForest)
@ -226,14 +218,10 @@ createObjectGroupsDeprecated(
RMS.SetProgress(95);
log("Creating straggler trees...");
var types = [oTree];
var num = floor(numStragglers / types.length);
for (let type of types)
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(type, 1, 1, 0, 3)], true, clForest),
0,
avoidClasses(clForest, 1, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6, clBaseResource, 6),
num);
createStragglerTrees(
[oTree],
avoidClasses(clForest, 1, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6, clBaseResource, 6),
clForest,
stragglerTrees);
ExportMap();