dallasgroot/0ad
1
0
Fork 0
mirror of https://gitea.wildfiregames.com/0ad/0ad synced 2026-06-16 05:13:58 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Cleanup most createArea and some createObjectGroup calls in random map scripts.

Browse source 
Inline the placer, terrainPainter, elevationPainter, group and sizes
helper variables that are used only once.
Thus do not hoist variable declarations from unrelated scopes.
Remove few dozens of painters that are overpainted by the
paintBasedOnTerrainHeight call afterwards.
Remove 334 noisy misaligned code comments (// terrains // widths //
blend radius and // some variation).
Label the createArea calls so that the reader knows what they do.
Remove unbenefitial Math.PI/8 grass min/max angle limitation.
Use height variables for the SmoothElevationPainter calls so that levels
can be modified more easily.
Use Math prototype functions instead of the unfortunate rmgen proxies.
Does not touch starting base code, Unknown maps, Snowflake Searocks and
Corsica & Sardinia which need special treatment.

This was SVN commit r20301.
This commit is contained in:
elexis 2017-10-15 17:53:12 +00:00
parent e396ff170e
commit 376d8b3d1e
50 changed files with 2117 additions and 2721 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -210,25 +210,24 @@ createLayeredPatches(
RMS.SetProgress(60);
log("Creating undersea bumps...");
placer = new ChainPlacer(1, floor(scaleByMapSize(4, 6)), floor(scaleByMapSize(16, 40)), 0.5);
painter = new SmoothElevationPainter(ELEVATION_SET, -2.5, 3);
createAreas(
placer,
[painter, paintClass(clCorals)],
new ChainPlacer(1, Math.floor(scaleByMapSize(4, 6)), Math.floor(scaleByMapSize(16, 40)), 0.5),
[
new SmoothElevationPainter(ELEVATION_SET, -2.5, 3),
paintClass(clCorals)
],
stayClasses(clWater, 6),
scaleByMapSize(10, 50)
);
log("Creating islands...");
placer = new ChainPlacer(1, floor(scaleByMapSize(4, 6)), floor(scaleByMapSize(30, 80)), 0.5);
var terrainPainter = new LayeredPainter(
[tWater, tShore, tHill], // terrains
[2 ,1] // widths
);
var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 6, 4);
createAreas(
placer,
[terrainPainter, elevationPainter, paintClass(clIsland)],
new ChainPlacer(1, Math.floor(scaleByMapSize(4, 6)), Math.floor(scaleByMapSize(30, 80)), 0.5),
[
new LayeredPainter([tWater, tShore, tHill], [2 ,1]),
new SmoothElevationPainter(ELEVATION_SET, 6, 4),
paintClass(clIsland)
],
[avoidClasses(clPlayer, 8, clForest, 1, clIsland, 15), stayClasses (clWater, 6)],
scaleByMapSize(1, 4) * numPlayers
);
@ -328,8 +327,9 @@ createFood
RMS.SetProgress(90);
var types = [oDatePalm, oSDatePalm, oCarob, oFanPalm, oPoplar, oCypress]; // some variation
createStragglerTrees(types, avoidClasses(clForest, 1, clWater, 2, clPlayer, 12, clMetal, 6, clHill, 1));
createStragglerTrees(
[oDatePalm, oSDatePalm, oCarob, oFanPalm, oPoplar, oCypress],
avoidClasses(clForest, 1, clWater, 2, clPlayer, 12, clMetal, 6, clHill, 1));
log("Creating straggler island trees...");
g_numStragglerTrees *= 10;

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

@ -139,15 +139,13 @@ for (var x = 0; x < mapSize; ++x)
lakeAreas.push([x, z]);
log("Creating water holes...");
placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), floor(scaleByMapSize(60, 100)), 5);
var terrainPainter = new LayeredPainter(
[tShore, tWater], // terrains
[1] // widths
);
var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -5, 7);
createAreas(
placer,
[terrainPainter, elevationPainter, paintClass(clWater)],
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), Math.floor(scaleByMapSize(60, 100)), 5),
[
new LayeredPainter([tShore, tWater], [1]),
new SmoothElevationPainter(ELEVATION_SET, -5, 7),
paintClass(clWater)
],
avoidClasses(clPlayer, 22, clWater, 8, clHill, 2),
scaleByMapSize(2, 5)
);
@ -214,14 +212,14 @@ createDecoration(
],
[
scaleByMapSize(8, 131),
scaleByMapSize(8, 131),
scaleByMapSize(8, 131)
],
avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0)
);
RMS.SetProgress(75);
log("Creating giraffes...");
group = new SimpleGroup(
var group = new SimpleGroup(
[new SimpleObject(oGiraffe, 2,4, 0,4), new SimpleObject(oGiraffe2, 0,2, 0,4)],
true, clFood
);

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

@ -207,15 +207,13 @@ for (var i = 0; i < numLakes; ++i)
let chosenPoint = pickRandom(lakeAreas);
placer = new ChainPlacer(1, floor(scaleByMapSize(4, 8)), floor(scaleByMapSize(40, 180)), 0.7, chosenPoint[0], chosenPoint[1]);
var terrainPainter = new LayeredPainter(
[tShore, tWater, tWater], // terrains
[1, 3] // widths
);
var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -5, 5);
var newLake = createAreas(
placer,
[terrainPainter, elevationPainter, paintClass(clWater)],
let newLake = createAreas(
new ChainPlacer(1, Math.floor(scaleByMapSize(4, 8)), Math.floor(scaleByMapSize(40, 180)), 0.7, chosenPoint[0], chosenPoint[1]),
[
new LayeredPainter([tShore, tWater, tWater], [1, 3]),
new SmoothElevationPainter(ELEVATION_SET, -5, 5),
paintClass(clWater)
],
avoidClasses(clPlayer, 20, clWater, 8),
1, 1
);

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

@ -98,7 +98,7 @@ for (var i = 0; i < numPlayers; i++)
// create the city patch
var cityRadius = radius/3;
placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
var placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
var painter = new LayeredPainter([tRoadWild, tRoad], [1]);
createArea(placer, painter, null);
@ -234,10 +234,14 @@ while (possibleEdges.length)
matrix[possibleEdges[index][0]][possibleEdges[index][1]] = true;
matrix[possibleEdges[index][1]][possibleEdges[index][0]] = true;
var selected, accept = true, tree = [], backtree = [];
let accept = true;
let tree = [];
let backtree = [];
while (q.length > 0)
{
selected = q.shift();
let selected = q.shift();
if (tree.indexOf(selected) == -1)
{
tree.push(selected);
@ -276,17 +280,14 @@ while (possibleEdges.length)
var iz = points[possibleEdges[index][0]][1];
var ix2 = points[possibleEdges[index][1]][0];
var iz2 = points[possibleEdges[index][1]][1];
var placer = new PathPlacer(ix, iz, ix2, iz2, scaleByMapSize(9,15), 0.4, 3*(scaleByMapSize(1,4)), 0.1, 0.1, 0.1);
var terrainPainter = new LayeredPainter(
[tCliff, tPrimary], // terrains
[3] // widths
);
var elevationPainter = new SmoothElevationPainter(
ELEVATION_SET, // type
30, // elevation
2 // blend radius
);
accept = createArea(placer, [terrainPainter, elevationPainter, paintClass(clHill)], avoidClasses(clPlayer, 20));
accept = createArea(
new PathPlacer(ix, iz, ix2, iz2, scaleByMapSize(9,15), 0.4, 3 * scaleByMapSize(1, 4), 0.1, 0.1, 0.1),
[
new LayeredPainter([tCliff, tPrimary], [3]),
new SmoothElevationPainter(ELEVATION_SET, 30, 2),
paintClass(clHill)
],
avoidClasses(clPlayer, 20));
if (accept == null)
{
@ -295,32 +296,16 @@ while (possibleEdges.length)
possibleEdges.splice(index,1);
continue;
}
else
{
placer = new ClumpPlacer(floor(PI*scaleByMapSize(9,15)*scaleByMapSize(9,15)/4), 0.95, 0.6, 10, ix, iz);
var terrainPainter = new LayeredPainter(
[tCliff, tPrimary], // terrains
[3] // widths
);
var elevationPainter = new SmoothElevationPainter(
ELEVATION_SET, // type
30, // elevation
2 // blend radius
);
createArea(placer, [terrainPainter, elevationPainter, paintClass(clHill)], avoidClasses(clPlayer, 5));
placer = new ClumpPlacer(floor(PI*scaleByMapSize(9,15)*scaleByMapSize(9,15)/4), 0.95, 0.6, 10, ix2, iz2);
var terrainPainter = new LayeredPainter(
[tCliff, tPrimary], // terrains
[3] // widths
);
var elevationPainter = new SmoothElevationPainter(
ELEVATION_SET, // type
30, // elevation
2 // blend radius
);
createArea(placer, [terrainPainter, elevationPainter, paintClass(clHill)], avoidClasses(clPlayer, 5));
}
for (let [x, z] of [[ix, iz], [ix2, iz2]])
createArea(
new ClumpPlacer(Math.floor(Math.PI * Math.pow(scaleByMapSize(9, 15) / 2, 2)), 0.95, 0.6, 10, x, z),
[
new LayeredPainter([tCliff, tPrimary], [3]),
new SmoothElevationPainter(ELEVATION_SET, 30, 2),
paintClass(clHill)
],
avoidClasses(clPlayer, 5));
for (var i = 0; i < possibleEdges.length; ++i)
{
@ -373,26 +358,21 @@ paintTerrainBasedOnHeight(3.1, 29, 0, tCliff);
paintTerrainBasedOnHeight(29, 30, 3, tSnowLimited);
log("Creating bumps...");
placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1);
painter = new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2);
createAreas(
placer,
painter,
new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1),
new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2),
avoidClasses(clPlayer, 10),
scaleByMapSize(100, 200)
);
scaleByMapSize(100, 200));
RMS.SetProgress(40);
log("Creating hills...");
placer = new ClumpPlacer(scaleByMapSize(40, 150), 0.2, 0.1, 1);
var terrainPainter = new LayeredPainter(
[tCliff, tSnowLimited], // terrains
[2] // widths
);
var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 30, 2);
createAreas(
placer,
[terrainPainter, elevationPainter, paintClass(clHill)],
new ClumpPlacer(scaleByMapSize(40, 150), 0.2, 0.1, 1),
[
new LayeredPainter([tCliff, tSnowLimited], [2]),
new SmoothElevationPainter(ELEVATION_SET, 30, 2),
paintClass(clHill)
],
avoidClasses(clPlayer, 20, clHill, 14),
scaleByMapSize(10, 80) * numPlayers
);
@ -410,57 +390,41 @@ var numStragglers = totalTrees * (1.0 - P_FOREST);
log("Creating forests...");
var types = [
[[tForestFloor, tPrimary, pForest], [tForestFloor, pForest]]
]; // some variation
];
var size = numForest / (scaleByMapSize(2,8) * numPlayers);
var num = floor(size / types.length);
for (var i = 0; i < types.length; ++i)
{
placer = new ClumpPlacer(numForest / num, 0.1, 0.1, 1);
painter = new LayeredPainter(
types[i], // terrains
[2] // widths
);
var num = Math.floor(size / types.length);
for (let type of types)
createAreas(
placer,
[painter, paintClass(clForest)],
new ClumpPlacer(numForest / num, 0.1, 0.1, 1),
[
new LayeredPainter(type, [2]),
paintClass(clForest)
],
avoidClasses(clPlayer, 12, clForest, 10, clHill, 0),
num
);
}
num);
RMS.SetProgress(60);
log("Creating dirt patches...");
var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
for (var i = 0; i < sizes.length; i++)
{
placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
painter = new LayeredPainter(
[[tDirt,tHalfSnow], [tHalfSnow,tSnowLimited]], // terrains
[2] // widths
);
for (let size of [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)])
createAreas(
placer,
[painter, paintClass(clDirt)],
new ClumpPlacer(size, 0.3, 0.06, 0.5),
[
new LayeredPainter([[tDirt, tHalfSnow], [tHalfSnow, tSnowLimited]], [2]),
paintClass(clDirt)
],
avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12),
scaleByMapSize(15, 45)
);
}
scaleByMapSize(15, 45));
log("Creating grass patches...");
var sizes = [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)];
for (var i = 0; i < sizes.length; i++)
{
placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
painter = new TerrainPainter(tSecondary);
for (let size of [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)])
createAreas(
placer,
painter,
new ClumpPlacer(size, 0.3, 0.06, 0.5),
new TerrainPainter(tSecondary),
avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12),
scaleByMapSize(15, 45)
);
}
scaleByMapSize(15, 45));
RMS.SetProgress(65);
log("Creating stone mines...");
@ -540,19 +504,14 @@ createObjectGroupsDeprecated(group, 0,
RMS.SetProgress(85);
log("Creating straggler trees...");
var types = [oPine, oPine]; // some variation
var types = [oPine, oPine];
var num = floor(numStragglers / types.length);
for (var i = 0; i < types.length; ++i)
{
group = new SimpleGroup(
[new SimpleObject(types[i], 1,1, 0,3)],
true, clForest
);
createObjectGroupsDeprecated(group, 0,
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
);
}
num);
log("Creating small grass tufts...");
var planetm = 1;

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

@ -123,17 +123,13 @@ for (var i = 0; i < numPlayers; i++)
RMS.SetProgress(20);
log("Creating bumps...");
placer = new ChainPlacer(1, floor(scaleByMapSize(4, 6)), floor(scaleByMapSize(2, 5)), 0.5);
painter = new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2);
createAreas(
placer,
painter,
new ChainPlacer(1, Math.floor(scaleByMapSize(4, 6)), Math.floor(scaleByMapSize(2, 5)), 0.5),
new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2),
avoidClasses(clPlayer, 13),
scaleByMapSize(300, 800)
);
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;
@ -143,26 +139,18 @@ var numForest = totalTrees * P_FOREST;
var numStragglers = totalTrees * (1.0 - P_FOREST);
log("Creating forests...");
var types = [[[tForestFloor, tGrass, pForest], [tForestFloor, pForest]]]; // some variation
var types = [[[tForestFloor, tGrass, pForest], [tForestFloor, pForest]]];
var size = numForest / (scaleByMapSize(2,8) * numPlayers);
var num = 4 * floor(size / types.length);
for (var i = 0; i < types.length; ++i)
{
placer = new ChainPlacer(1, floor(scaleByMapSize(2, 3)), 4, 1);
painter = new LayeredPainter(
types[i], // terrains
[2] // widths
);
for (let type of types)
createAreas(
placer,
[painter, paintClass(clForest)],
new ChainPlacer(1, Math.floor(scaleByMapSize(2, 3)), 4, 1),
[
new LayeredPainter(type, [2]),
paintClass(clForest)
],
avoidClasses(clPlayer, 13, clForest, 20, clHill, 1),
num
);
}
num);
RMS.SetProgress(50);
log("Creating grass patches...");
@ -281,19 +269,14 @@ createObjectGroupsDeprecated(group, 0,
RMS.SetProgress(85);
log("Creating straggler trees...");
var types = [oBush, oPoplar]; // some variation
var types = [oBush, oPoplar];
var num = floor(numStragglers / types.length);
for (var i = 0; i < types.length; ++i)
{
group = new SimpleGroup(
[new SimpleObject(types[i], 1,1, 0,3)],
true, clForest
);
createObjectGroupsDeprecated(group, 0,
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
);
}
num);
log("Creating large grass tufts...");
group = new SimpleGroup(

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

@ -154,18 +154,21 @@ for (var i = 0; i < numPlayers; i++)
}
log("Creating islands...");
placer = new ChainPlacer(floor(scaleByMapSize(4, 8)), floor(scaleByMapSize(8, 14)), floor(scaleByMapSize(25, 60)), 0.07, undefined, undefined, scaleByMapSize(30,70));
terrainPainter = new LayeredPainter(
[tMainTerrain, tMainTerrain], // terrains
[2] // widths
);
elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 4);
createAreas(
placer,
[terrainPainter, elevationPainter, paintClass(clLand)],
new ChainPlacer(
Math.floor(scaleByMapSize(4, 8)),
Math.floor(scaleByMapSize(8, 14)),
Math.floor(scaleByMapSize(25, 60)),
0.07,
undefined,
undefined,
scaleByMapSize(30, 70)),
[
new SmoothElevationPainter(ELEVATION_SET, 3, 4),
paintClass(clLand)
],
null,
scaleByMapSize(1, 5) * randIntInclusive(5, 10)
);
scaleByMapSize(1, 5) * randIntInclusive(5, 10));
paintTerrainBasedOnHeight(2.4, 3.4, 3, tMainTerrain);
paintTerrainBasedOnHeight(1, 3, 0, tShore);
@ -299,8 +302,10 @@ createFood
RMS.SetProgress(85);
log("Creating straggler trees...");
var types = [oTree1, oTree2, oTree4, oTree3]; // some variation
createStragglerTrees(types, [avoidClasses(clForest, 7, clHill, 1, clPlayer, 3, clMetal, 6, clRock, 6), stayClasses(clLand, 7)]);
createStragglerTrees(
[oTree1, oTree2, oTree4, oTree3],
[avoidClasses(clForest, 7, clHill, 1, clPlayer, 3, clMetal, 6, clRock, 6), stayClasses(clLand, 7)]);
setWaterWaviness(4.0);
setWaterType("ocean");

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

@ -62,22 +62,13 @@ var clFood = createTileClass();
var clBaseResource = createTileClass();
var clHillDeco = createTileClass();
// Create central dip
var centerX = fractionToTiles(0.5);
var centerZ = fractionToTiles(0.5);
var placer = new ClumpPlacer(scaleByMapSize(mapSize * 70, mapSize * 300), 0.94, 0.05, 0.1, centerX, centerZ);
var elevationPainter = new SmoothElevationPainter(
ELEVATION_SET,
30,
3
);
var painter = new LayeredPainter(
[tCliff, tGrass], // terrains
[3] // widths
);
createArea(placer,
[painter, elevationPainter],
log("Creating the central dip...");
createArea(
new ClumpPlacer(mapSize * scaleByMapSize(70, 300), 0.94, 0.05, 0.1, fractionToTiles(0.5), fractionToTiles(0.5)),
[
new LayeredPainter([tCliff, tGrass], [3]),
new SmoothElevationPainter(ELEVATION_SET, 30, 3)
],
null);
RMS.SetProgress(5);
@ -207,134 +198,87 @@ for (var i=0; i < numPlayers; i++)
RMS.SetProgress(30);
log("Creating hills...");
var sizes = [scaleByMapSize(50, 800), scaleByMapSize(50, 400), scaleByMapSize(10, 30), scaleByMapSize(10, 30)];
for (var i = 0; i < sizes.length; i++)
for (let size of [scaleByMapSize(50, 800), scaleByMapSize(50, 400), scaleByMapSize(10, 30), scaleByMapSize(10, 30)])
{
var placer = new ClumpPlacer(sizes[i], 0.1, 0.2, 0.1);
var painter = new LayeredPainter(
[tCliff, [tForestFloor, tForestFloor, tCliff]], // terrains
[2] // widths
);
var elevationPainter = new SmoothElevationPainter(
ELEVATION_SET,
50,
sizes[i] < 50 ? 2 : 4
);
var mountains = createAreas(
placer,
[painter, paintClass(clHill), elevationPainter],
let mountains = createAreas(
new ClumpPlacer(size, 0.1, 0.2, 0.1),
[
new LayeredPainter([tCliff, [tForestFloor, tForestFloor, tCliff]], [2]),
new SmoothElevationPainter(ELEVATION_SET, 50, size < 50 ? 2 : 4),
paintClass(clHill)
],
avoidClasses(clPlayer, 8, clBaseResource, 2, clHill, 5),
scaleByMapSize(1, 4)
);
if(sizes[i] > 100 && mountains.length > 0)
{
var placer = new ClumpPlacer(sizes[i] * 0.3, 0.94, 0.05, 0.1);
var elevationPainter = new SmoothElevationPainter(
ELEVATION_MODIFY,
10,
3
);
var painter = new LayeredPainter(
[tCliff, tForestFloor], // terrains
[2] // widths
);
scaleByMapSize(1, 4));
if (size > 100 && mountains.length)
createAreasInAreas(
placer,
[painter, elevationPainter],
new ClumpPlacer(size * 0.3, 0.94, 0.05, 0.1),
[
new LayeredPainter([tCliff, tForestFloor], [2]),
new SmoothElevationPainter(ELEVATION_MODIFY, 10, 3)
],
stayClasses(clHill, 4),
mountains.length * 2,
20,
mountains
);
}
mountains);
var placer = new ClumpPlacer(sizes[i], 0.1, 0.2, 0.1);
var elevationPainter = new SmoothElevationPainter(
ELEVATION_SET,
10,
2
);
var ravine = createAreas(
placer,
[painter, paintClass(clHill), elevationPainter],
avoidClasses(clPlayer, 6, clBaseResource, 2, clHill, 5),
scaleByMapSize(1, 3)
);
if(sizes[i] > 150 && ravine.length > 0)
{
// Place huts in ravines
var group = new RandomGroup(
let ravine = createAreas(
new ClumpPlacer(size, 0.1, 0.2, 0.1),
[
new SimpleObject(aCeltHouse, 0,1, 4,5),
new SimpleObject(aCeltLongHouse, 1,1, 4,5)
], true, clHillDeco);
painter,
paintClass(clHill),
new SmoothElevationPainter(ELEVATION_SET, 10, 2)
],
avoidClasses(clPlayer, 6, clBaseResource, 2, clHill, 5),
scaleByMapSize(1, 3));
if (size > 150 && ravine.length)
{
log("Placing huts in ravines...");
createObjectGroupsByAreasDeprecated(
group, 0,
new RandomGroup(
[
new SimpleObject(aCeltHouse, 0, 1, 4, 5),
new SimpleObject(aCeltLongHouse, 1, 1, 4, 5)
],
true,
clHillDeco),
0,
[avoidClasses(clHillDeco, 3), stayClasses(clHill, 3)],
ravine.length * 5, 20,
ravine
);
ravine);
var group = new RandomGroup(
[
new SimpleObject(aCeltHomestead, 1,1, 1,1)
], true, clHillDeco);
createObjectGroupsByAreasDeprecated(
group, 0,
new RandomGroup([new SimpleObject(aCeltHomestead, 1, 1, 1, 1)], true, clHillDeco),
0,
[avoidClasses(clHillDeco, 5), stayClasses(clHill, 4)],
ravine.length * 2, 100,
ravine
);
ravine);
// Place noise
var placer = new ClumpPlacer(sizes[i] * 0.3, 0.94, 0.05, 0.1);
var elevationPainter = new SmoothElevationPainter(
ELEVATION_SET,
2,
2
);
var painter = new LayeredPainter(
[tCliff, tForestFloor], // terrains
[2] // widths
);
createAreasInAreas(
placer,
[painter, elevationPainter],
new ClumpPlacer(size * 0.3, 0.94, 0.05, 0.1),
[
new LayeredPainter([tCliff, tForestFloor], [2]),
new SmoothElevationPainter(ELEVATION_SET, 2, 2)
],
[avoidClasses(clHillDeco, 2), stayClasses(clHill, 0)],
ravine.length * 2,
20,
ravine
);
var placer = new ClumpPlacer(sizes[i] * 0.1, 0.3, 0.05, 0.1);
var elevationPainter = new SmoothElevationPainter(
ELEVATION_SET,
40,
2
);
var painter = new LayeredPainter(
[tCliff, tForestFloor], // terrains
[2] // widths
);
ravine);
createAreasInAreas(
placer,
[painter, paintClass(clHill), elevationPainter],
new ClumpPlacer(size * 0.1, 0.3, 0.05, 0.1),
[
new LayeredPainter([tCliff, tForestFloor], [2]),
new SmoothElevationPainter(ELEVATION_SET, 40, 2),
paintClass(clHill)
],
[avoidClasses(clHillDeco, 2), borderClasses(clHill, 15, 1)],
ravine.length * 2,
50,
ravine
);
ravine);
}
RMS.SetProgress(30 + (20 * (i / sizes.length)));
}
RMS.SetProgress(50);
@ -423,35 +367,21 @@ createAreasInAreas(
RMS.SetProgress(70);
log("Creating grass patches...");
var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
for (var i = 0; i < sizes.length; i++)
{
placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
painter = new LayeredPainter(
[[tGrass,tGrassPatch],[tGrassPatch,tGrass], [tGrass,tGrassPatch]], // terrains
[1,1] // widths
);
for (let size of [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)])
createAreas(
placer,
painter,
new ClumpPlacer(size, 0.3, 0.06, 0.5),
new LayeredPainter([[tGrass, tGrassPatch], [tGrassPatch, tGrass], [tGrass, tGrassPatch]], [1, 1]),
avoidClasses(clForest, 0, clHill, 2, clPlayer, 5),
scaleByMapSize(15, 45)
);
}
scaleByMapSize(15, 45));
log("Creating chopped forest patches...");
var sizes = [scaleByMapSize(20, 120)];
for (var i = 0; i < sizes.length; i++)
{
placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
painter = new TerrainPainter(tForestFloor);
for (let size of [scaleByMapSize(20, 120)])
createAreas(
placer,
painter,
new ClumpPlacer(size, 0.3, 0.06, 0.5),
new TerrainPainter(tForestFloor),
avoidClasses(clForest, 1, clHill, 2, clPlayer, 5),
scaleByMapSize(4, 12)
);
}
scaleByMapSize(4, 12));
RMS.SetProgress(75);
log("Creating stone mines...");
@ -544,21 +474,15 @@ createObjectGroupsByAreasDeprecated(
RMS.SetProgress(90);
log("Creating straggler trees...");
var types = [oOak, oOakLarge, oPine, oAleppoPine]; // some variation
var types = [oOak, oOakLarge, oPine, oAleppoPine];
var num = floor(numStragglers / types.length);
for (var i = 0; i < types.length; ++i)
{
group = new SimpleGroup(
[new SimpleObject(types[i], 1,1, 0,3)],
true, clForest
);
createObjectGroupsByAreasDeprecated(group, 0,
for (let type of types)
createObjectGroupsByAreasDeprecated(
new SimpleGroup([new SimpleObject(type, 1, 1, 0, 3)], true, clForest),
0,
avoidClasses(clForest, 4, clHill, 5, clPlayer, 10, clBaseResource, 2, clMetal, 5, clRock, 5),
num, 20,
[explorableArea]
);
}
[explorableArea]);
RMS.SetProgress(95);

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

@ -246,23 +246,19 @@ createObjectGroupsDeprecated(group, 0,
RMS.SetProgress(80);
var types = [oCarob, oAleppoPine]; // some variation
createStragglerTrees(types, avoidClasses(clForest, 1, clHill, 1, clPlayer, 10, clMetal, 6, clRock, 6, clTreasure, 4));
createStragglerTrees(
[oCarob, oAleppoPine],
avoidClasses(clForest, 1, clHill, 1, clPlayer, 10, clMetal, 6, clRock, 6, clTreasure, 4));
log("Creating hill trees...");
var types = [aCarob, aAleppoPine]; // some variation
var types = [aCarob, aAleppoPine];
var num = floor(0.2 * g_numStragglerTrees / types.length);
for (var i = 0; i < types.length; ++i)
{
group = new SimpleGroup(
[new SimpleObject(types[i], 1,1, 0,3)],
true, clForest
);
createObjectGroupsDeprecated(group, 0,
for (let type of types)
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(type, 1, 1, 0, 3)], true, clForest),
0,
stayClasses(clHill, 2),
num
);
}
num);
setFogFactor(0.2);
setFogThickness(0.14);

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

@ -165,15 +165,13 @@ RMS.SetProgress(10);
log("Creating lakes...");
var numLakes = round(scaleByMapSize(1,4) * numPlayers);
placer = new ClumpPlacer(scaleByMapSize(100,250), 0.8, 0.1, 10);
terrainPainter = new LayeredPainter(
[tShoreBlend, tShore, tWater], // terrains
[1,1] // widths
);
elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -7, 6);
var waterAreas = createAreas(
placer,
[terrainPainter, elevationPainter, paintClass(clWater)],
new ClumpPlacer(scaleByMapSize(100, 250), 0.8, 0.1, 10),
[
new LayeredPainter([tShoreBlend, tShore, tWater], [1, 1]),
new SmoothElevationPainter(ELEVATION_SET, -7, 6),
paintClass(clWater)
],
avoidClasses(clPlayer, 2, clWater, 20),
numLakes
);
@ -301,14 +299,14 @@ createFood
);
RMS.SetProgress(85);
log("Creating metal mines...");
var types = [oOak, oOakLarge, oPine, oApple]; // some variation
createStragglerTrees(types, avoidClasses(clWater, 1, clForest, 1, clHill, 1, clPlayer, 1, clMetal, 6, clRock, 6));
createStragglerTrees(
[oOak, oOakLarge, oPine, oApple],
avoidClasses(clWater, 1, clForest, 1, clHill, 1, clPlayer, 1, clMetal, 6, clRock, 6));
RMS.SetProgress(90);
setSkySet("cirrus");
setWaterColor(0.447, 0.412, 0.322); // muddy brown
setWaterTint(0.447, 0.412, 0.322); // muddy brown
setWaterTint(0.447, 0.412, 0.322);
setWaterMurkiness(1.0);
setWaterWaviness(3.0);
setWaterType("lake");

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

@ -57,27 +57,11 @@ var clFood = createTileClass();
var clBaseResource = createTileClass();
var clLand = createTileClass();
var landHeight = 3;
var hillHeight = 30;
initTerrain(tMainTerrain);
var fx = fractionToTiles(0.5);
var fz = fractionToTiles(0.5);
ix = round(fx);
iz = round(fz);
var lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 6))));
var placer = new ClumpPlacer(mapArea * 0.065 * lSize, 0.7, 0.1, 10, ix, iz);
var terrainPainter = new LayeredPainter(
[tMainTerrain, tMainTerrain], // terrains
[3] // widths
);
var elevationPainter = new SmoothElevationPainter(
ELEVATION_SET, // type
3, // elevation
3 // blend radius
);
createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
var [playerIDs, playerX, playerZ] = radialPlayerPlacement();
for (var i = 0; i < numPlayers; i++)
@ -169,51 +153,57 @@ for (var i = 0; i < numPlayers; i++)
}
placer = new ClumpPlacer(150, 0.6, 0.3, 10, fractionToTiles(0.5), fractionToTiles(0.5));
var painter = new LayeredPainter([tRoad, tRoad], [1]);
createArea(placer, [painter, paintClass(clHill)], null);
log("Creating center area...");
var center = Math.round(fractionToTiles(0.5));
var lSize = Math.pow(scaleByMapSize(1, 6), 1/8);
for (var i = 0; i < scaleByMapSize(9,16); i++)
{
var placer = new PathPlacer(
randIntExclusive(1, mapSize),
randIntExclusive(1, mapSize),
randIntExclusive(1, mapSize),
randIntExclusive(1, mapSize),
scaleByMapSize(11,16),
0.4,
3 * scaleByMapSize(1,4),
0.1,
0);
createArea(
new ClumpPlacer(mapArea * 0.065 * lSize, 0.7, 0.1, 10, center, center),
[
new LayeredPainter([tMainTerrain, tMainTerrain], [3]),
new SmoothElevationPainter(ELEVATION_SET, landHeight, 3),
paintClass(clLand)
],
null);
var terrainPainter = new LayeredPainter(
[tMainTerrain, tMainTerrain], // terrains
[3] // widths
);
var elevationPainter = new SmoothElevationPainter(
ELEVATION_SET, // type
30, // elevation
3 // blend radius
);
createArea(placer, [terrainPainter, elevationPainter, paintClass(clHill2)], avoidClasses(clPlayer, 6, clHill2, 3, clHill, 2));
}
createArea(
new ClumpPlacer(150, 0.6, 0.3, 10, center, center),
paintClass(clHill),
null);
for (var g = 0; g < scaleByMapSize(5,30); g++)
log("Creating hills...");
for (let i = 0; i < scaleByMapSize(9, 16); ++i)
createArea(
new PathPlacer(
randIntExclusive(1, mapSize),
randIntExclusive(1, mapSize),
randIntExclusive(1, mapSize),
randIntExclusive(1, mapSize),
scaleByMapSize(11, 16),
0.4,
3 * scaleByMapSize(1, 4),
0.1,
0),
[
new SmoothElevationPainter(ELEVATION_SET, hillHeight, 3),
paintClass(clHill2)
],
avoidClasses(clPlayer, 6, clHill2, 3, clHill, 2));
for (let g = 0; g < scaleByMapSize(5, 30); ++g)
{
var tx = randIntInclusive(1, mapSize - 1);
var tz = randIntInclusive(1, mapSize - 1);
placer = new ClumpPlacer(mapArea * 0.01 * lSize, 0.7, 0.1, 10, tx, tz);
terrainPainter = new LayeredPainter(
[tMainTerrain, tMainTerrain], // terrains
[3] // widths
);
elevationPainter = new SmoothElevationPainter(
ELEVATION_SET, // type
3, // elevation
3 // blend radius
);
var newarea = createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], avoidClasses(clLand, 6));
var newarea = createArea(
new ClumpPlacer(mapArea * 0.01 * lSize, 0.7, 0.1, 10, tx, tz),
[
new LayeredPainter([tMainTerrain, tMainTerrain], [3]),
new SmoothElevationPainter(ELEVATION_SET, landHeight, 3),
paintClass(clLand)
],
avoidClasses(clLand, 6));
if (newarea !== null)
{
var distances = [];
@ -222,10 +212,10 @@ for (var g = 0; g < scaleByMapSize(5,30); g++)
var p1 = -1;
var p2 = 0;
for (var i = 0; i < numPlayers; i++)
for (let i = 0; i < numPlayers; ++i)
distances.push(sqrt((tx-mapSize*playerX[i])*(tx-mapSize*playerX[i])+(tz-mapSize*playerZ[i])*(tz-mapSize*playerZ[i])));
for (var a = 0; a < numPlayers; a++)
for (let a = 0; a < numPlayers; ++a)
{
if (d1 >= distances[a])
{
@ -241,82 +231,62 @@ for (var g = 0; g < scaleByMapSize(5,30); g++)
}
}
var placer = new PathPlacer(tx, tz, mapSize*playerX[p1], mapSize*playerZ[p1], scaleByMapSize(11,17), 0.4, 3*(scaleByMapSize(1,4)), 0.1, 0.1);
var terrainPainter = new LayeredPainter(
[tMainTerrain, tMainTerrain], // terrains
[3] // widths
);
var elevationPainter = new SmoothElevationPainter(
ELEVATION_SET, // type
3, // elevation
3 // blend radius
);
createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
createArea(
new PathPlacer(tx, tz, mapSize * playerX[p1], mapSize * playerZ[p1], scaleByMapSize(11, 17), 0.4, 3 * scaleByMapSize(1, 4), 0.1, 0.1),
[
new LayeredPainter([tMainTerrain, tMainTerrain], [3]),
new SmoothElevationPainter(ELEVATION_SET, landHeight, 3),
paintClass(clLand)
],
null);
if (numPlayers > 1)
{
var placer = new PathPlacer(tx, tz, mapSize*playerX[p2], mapSize*playerZ[p2], scaleByMapSize(11,17), 0.4, 3*(scaleByMapSize(1,4)), 0.1, 0.1);
var terrainPainter = new LayeredPainter(
[tMainTerrain, tMainTerrain], // terrains
[3] // widths
);
var elevationPainter = new SmoothElevationPainter(
ELEVATION_SET, // type
3, // elevation
3 // blend radius
);
createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
}
createArea(
new PathPlacer(tx, tz, mapSize * playerX[p2], mapSize * playerZ[p2], scaleByMapSize(11, 17), 0.4, 3 * scaleByMapSize(1, 4), 0.1, 0.1),
[
new LayeredPainter([tMainTerrain, tMainTerrain], [3]),
new SmoothElevationPainter(ELEVATION_SET, landHeight, 3),
paintClass(clLand)
],
null);
}
}
for (var i = 0; i < numPlayers; i++)
{
if (i+1 == numPlayers)
{
var placer = new PathPlacer(fractionToTiles(playerX[i]), fractionToTiles(playerZ[i]), fractionToTiles(playerX[0]), fractionToTiles(playerZ[0]), scaleByMapSize(8,13), 0.4, 3*(scaleByMapSize(1,4)), 0.1, 0);
}
else
{
var placer = new PathPlacer(fractionToTiles(playerX[i]), fractionToTiles(playerZ[i]), fractionToTiles(playerX[i+1]), fractionToTiles(playerZ[i+1]), scaleByMapSize(8,13), 0.4, 3*(scaleByMapSize(1,4)), 0.1, 0);
}
var terrainPainter = new LayeredPainter(
[tRoadWild, tRoad], // terrains
[1] // widths
);
var elevationPainter = new SmoothElevationPainter(
ELEVATION_SET, // type
3, // elevation
2 // blend radius
);
createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand), paintClass(clHill)], null);
var placer = new PathPlacer(fractionToTiles(playerX[i]), fractionToTiles(playerZ[i]), fractionToTiles(0.5), fractionToTiles(0.5), scaleByMapSize(8,13), 0.4, 3*(scaleByMapSize(1,4)), 0.1, 0);
var terrainPainter = new LayeredPainter(
[tRoadWild, tRoad], // terrains
[1] // widths
);
var elevationPainter = new SmoothElevationPainter(
ELEVATION_SET, // type
3, // elevation
2 // blend radius
);
createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand), paintClass(clHill)], null);
}
for (var i = 0; i < numPlayers; i++)
for (let i = 0; i < numPlayers; ++i)
{
// create the city patch
var cityRadius = radius/3;
placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, fractionToTiles(playerX[i]), fractionToTiles(playerZ[i]));
var painter = new LayeredPainter([tRoad, tRoad], [1]);
createArea(placer, [painter, paintClass(clPlayer)], null);
log("Creating path from player to center and to neighbor...");
let neighbor = i + 1 < numPlayers ? i + 1 : 0;
for (let [x, z] of [[playerX[neighbor], playerZ[neighbor]], [0.5, 0.5]])
createArea(
new PathPlacer(
fractionToTiles(playerX[i]),
fractionToTiles(playerZ[i]),
fractionToTiles(x),
fractionToTiles(z),
scaleByMapSize(8, 13),
0.4,
3 * scaleByMapSize(1, 4),
0.1,
0),
[
new LayeredPainter([tRoadWild, tRoad], [1]),
new SmoothElevationPainter(ELEVATION_SET, landHeight, 2),
paintClass(clLand),
paintClass(clHill)
],
null);
}
placer = new ClumpPlacer(150, 0.6, 0.3, 10, fractionToTiles(0.5), fractionToTiles(0.5));
var painter = new LayeredPainter([tRoad, tRoad], [1]);
createArea(placer, [painter, paintClass(clHill)], null);
createArea(
new ClumpPlacer(150, 0.6, 0.3, 10, center, center),
new LayeredPainter([tRoad, tRoad], [1]),
null);
RMS.SetProgress(20);
@ -438,16 +408,13 @@ createFood
RMS.SetProgress(85);
log("Creating straggler trees...");
var types = [oTree1, oTree2, oTree4, oTree3]; // some variation
createStragglerTrees(types, [avoidClasses(clForest, 1, clHill, 1, clPlayer, 9, clMetal, 6, clRock, 6, clHill2, 1), stayClasses(clLand, 3)]);
createStragglerTrees(
[oTree1, oTree2, oTree4, oTree3],
[avoidClasses(clForest, 1, clHill, 1, clPlayer, 9, clMetal, 6, clRock, 6, clHill2, 1), stayClasses(clLand, 3)]);
log("Creating treasures...");
var fx = fractionToTiles(0.5);
var fz = fractionToTiles(0.5);
for (let i = 0; i < randIntInclusive(3, 8); ++i)
placeObject(fx + randFloat(-7, 7), fz + randFloat(-7, 7), oWood, 0, randFloat(0, 2 * PI));
for (let i = 0; i < randIntInclusive(3, 8); ++i)
placeObject(fx + randFloat(-7, 7), fz + randFloat(-7, 7), oFood, 0, randFloat(0, 2 * PI));
for (let template of [oFood, oWood])
placeObject(center + randFloat(-7, 7), center + randFloat(-7, 7), template, 0, randFloat(0, 2 * Math.PI));
ExportMap();

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

@ -55,24 +55,22 @@ var clFood = createTileClass();
var clBaseResource = createTileClass();
var clLand = createTileClass();
initTerrain(tWater);
var fx = fractionToTiles(0.5);
var fz = fractionToTiles(0.5);
ix = round(fx);
iz = round(fz);
var placer = new ChainPlacer(2, floor(scaleByMapSize(5, 12)), floor(scaleByMapSize(60, 700)), 1, ix, iz, 0, [floor(mapSize * 0.33)]);
var terrainPainter = new LayeredPainter(
[tMainTerrain, tMainTerrain], // terrains
[3] // widths
);
var elevationPainter = new SmoothElevationPainter(
ELEVATION_SET, // type
3, // elevation
4 // blend radius
);
createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
log("Creating continent...");
createArea(
new ChainPlacer(
2,
Math.floor(scaleByMapSize(5, 12)),
Math.floor(scaleByMapSize(60, 700)),
1,
Math.round(fractionToTiles(0.5)),
Math.round(fractionToTiles(0.5)),
0,
[Math.floor(mapSize * 0.33)]),
[
new SmoothElevationPainter(ELEVATION_SET, 3, 4),
paintClass(clLand)
],
null);
var [playerIDs, playerX, playerZ] = radialPlayerPlacement(0.25);
@ -292,8 +290,10 @@ createFood
RMS.SetProgress(85);
log("Creating straggler trees...");
var types = [oTree1, oTree2, oTree4, oTree3]; // some variation
createStragglerTrees(types, [avoidClasses(clForest, 7, clHill, 1, clPlayer, 9, clMetal, 6, clRock, 6), stayClasses(clLand, 7)]);
createStragglerTrees(
[oTree1, oTree2, oTree4, oTree3],
[avoidClasses(clForest, 7, clHill, 1, clPlayer, 9, clMetal, 6, clRock, 6), stayClasses(clLand, 7)]);
setWaterWaviness(1.0);
setWaterType("ocean");

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

@ -300,8 +300,9 @@ createFood
RMS.SetProgress(90);
log("Creating straggler trees...");
var types = [oDatePalm, oSDatePalm, oCarob, oFanPalm, oPoplar, oCypress]; // some variation
createStragglerTrees(types, avoidClasses(clForest, 1, clWater, 2, clPlayer, 8, clMetal, 6, clHill, 1));
createStragglerTrees(
[oDatePalm, oSDatePalm, oCarob, oFanPalm, oPoplar, oCypress],
avoidClasses(clForest, 1, clWater, 2, clPlayer, 8, clMetal, 6, clHill, 1));
setSkySet("sunny");
setSunColor(0.917, 0.828, 0.734);

99
binaries/data/mods/public/maps/random/cycladic_archipelago.js
View file

@ -192,10 +192,8 @@ for (let i = 0; i < numPlayers; ++i)
);
createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
}
RMS.SetProgress(15);
log("Populating islands ...");
//nPlayer is the player we are on i is the island we are on
var nPlayer = 0;
for (let i = 0; i < numIslands; ++i)
if (numPlayers >= 6 || i == startingPlaces[numPlayers-1][nPlayer])
@ -221,62 +219,53 @@ for (let i = 0; i < numIslands; ++i)
RMS.SetProgress(20);
log("Creating bumps...");
placer = new ClumpPlacer(scaleByMapSize(20, 60), 0.3, 0.06, 1);
painter = new SmoothElevationPainter(ELEVATION_MODIFY, 2, 3);
createAreasInAreas(
placer,
painter,
new ClumpPlacer(scaleByMapSize(20, 60), 0.3, 0.06, 1),
new SmoothElevationPainter(ELEVATION_MODIFY, 2, 3),
avoidClasses(clCity, 0),
scaleByMapSize(25, 75),15,
areas
);
areas);
RMS.SetProgress(34);
log("Creating hills...");
placer = new ClumpPlacer(scaleByMapSize(20, 150), 0.2, 0.1, 1);
var terrainPainter = new LayeredPainter(
[tCliff, tCliffShrubs], // terrains
[2] // widths
);
var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 12, 2);
createAreasInAreas(
placer,
[terrainPainter, elevationPainter, paintClass(clHill)],
new ClumpPlacer(scaleByMapSize(20, 150), 0.2, 0.1, 1),
[
new LayeredPainter([tCliff, tCliffShrubs], [2]),
new SmoothElevationPainter(ELEVATION_SET, 12, 2),
paintClass(clHill)
],
avoidClasses(clCity, 15, clHill, 15),
scaleByMapSize(5, 30), 15,
areas
);
areas);
RMS.SetProgress(38);
// Find all water
for (var ix = 0; ix < mapSize; ix++)
for (var iz = 0; iz < mapSize; iz++)
if (getHeight(ix,iz) < 0)
addToClass(ix,iz,clWater);
log("Creating forests...");
var types = [
var forestTypes = [
[[tForestFloor, tGrass, pPalmForest], [tForestFloor, pPalmForest]],
[[tForestFloor, tGrass, pPineForest], [tForestFloor, pPineForest]],
[[tForestFloor, tGrass, pPoplarForest], [tForestFloor, pPoplarForest]],
[[tForestFloor, tGrass, pMainForest], [tForestFloor, pMainForest]]
]; // some variation
var size = 5; //size
var num = scaleByMapSize(10, 64); //number
for (var i = 0; i < types.length; ++i)
{
placer = new ClumpPlacer(randIntInclusive(6, 17), 0.1, 0.1, 1);
painter = new LayeredPainter(
types[i], // terrains
[2] // widths
);
];
for (let type of forestTypes)
createAreasInAreas(
placer,
[painter, paintClass(clForest)],
new ClumpPlacer(randIntInclusive(6, 17), 0.1, 0.1, 1),
[
new LayeredPainter(type, [2]),
paintClass(clForest)
],
avoidClasses(clCity, 1, clWater, 3, clForest, 3, clHill, 1, clBaseResource, 4),
num, 20, areas
);
}
scaleByMapSize(10, 64),
20,
areas);
RMS.SetProgress(42);
log("Creating stone mines...");
@ -288,7 +277,7 @@ createObjectGroupsByAreasDeprecated(group, 0,
RMS.SetProgress(46);
log("Creating small stone mines...");
group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
var group = new SimpleGroup([new SimpleObject(oStoneSmall, 2,5, 1,3)], true, clRock);
createObjectGroupsByAreasDeprecated(group, 0,
[avoidClasses(clWater, 1, clForest, 1, clHill, 1, clPlayer, 5, clRock, 2)],
scaleByMapSize(4,16), 200, areas
@ -304,33 +293,31 @@ createObjectGroupsByAreasDeprecated(group, 0,
RMS.SetProgress(54);
log("Creating shrub patches...");
var sizes = [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)];
for (var i = 0; i < sizes.length; i++)
{
placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
painter = new LayeredPainter([tBeachBlend,tGrassShrubs],[1]);
for (let size of [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)])
createAreasInAreas(
placer,
[painter, paintClass(clDirt)],
new ClumpPlacer(size, 0.3, 0.06, 0.5),
[
new LayeredPainter([tBeachBlend, tGrassShrubs], [1]),
paintClass(clDirt)
],
avoidClasses(clWater, 3, clHill, 0, clDirt, 6, clCity, 0, clBaseResource, 4),
scaleByMapSize(4, 16), 20, areas
);
}
scaleByMapSize(4, 16),
20,
areas);
RMS.SetProgress(58);
log("Creating grass patches...");
var sizes = [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)];
for (var i = 0; i < sizes.length; i++)
{
placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
painter = new LayeredPainter([tGrassDry],[]);
for (let size of [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)])
createAreasInAreas(
placer,
[painter, paintClass(clDirt)],
new ClumpPlacer(size, 0.3, 0.06, 0.5),
[
new LayeredPainter([tGrassDry], []),
paintClass(clDirt)
],
avoidClasses(clWater, 3, clHill, 0, clDirt, 6, clCity, 0, clBaseResource, 4),
scaleByMapSize(4, 16), 20, areas
);
}
scaleByMapSize(4, 16),
20,
areas);
RMS.SetProgress(62);
log("Creating straggler trees...");

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

@ -36,7 +36,6 @@ const aBushSmall = "actor|props/flora/bush_medit_sm_lush.xml";
const aReeds = "actor|props/flora/reeds_pond_lush_a.xml";
const aLillies = "actor|props/flora/water_lillies.xml";
// terrain + entity (for painting)
const pForestD = [tGrassDForest + TERRAIN_SEPARATOR + oBeech, tGrassDForest];
InitMap();
@ -165,7 +164,7 @@ paintRiver({
RMS.SetProgress(20);
log("Creating rivers");
log("Creating tributaries...");
for (let i = 0; i <= randIntInclusive(8, scaleByMapSize(12, 20)); ++i)
{
var cLocation = randFloat(0.05, 0.95);
@ -173,36 +172,64 @@ for (let i = 0; i <= randIntInclusive(8, scaleByMapSize(12, 20)); ++i)
var sign = randBool() ? 1 : -1;
var tang = sign * PI * randFloat(0.2, 0.8);
var cDistance = sign * 0.05;
let someRadius = scaleByMapSize(10, 20);
var point = getTIPIADBON([fractionToTiles(cLocation), fractionToTiles(0.5 + cDistance)], [fractionToTiles(cLocation), fractionToTiles(0.5 - cDistance)], [-6, -1.5], 0.5, 4, 0.01);
if (point !== undefined)
{
var placer = new PathPlacer(floor(point[0]), floor(point[1]), floor(fractionToTiles(0.5 + 0.49*cos(tang))), floor(fractionToTiles(0.5 + 0.49*sin(tang))), scaleByMapSize(10,20), 0.4, 3*(scaleByMapSize(1,4)), 0.1, 0.05);
var terrainPainter = new LayeredPainter(
[tShore, tWater, tWater], // terrains
[1, 3] // widths
);
var elevationPainter = new SmoothElevationPainter(
ELEVATION_SET, // type
-4, // elevation
4 // blend radius
);
var success = createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 8, clWater, 3, clShallow, 2));
if (success !== undefined)
{
placer = new ClumpPlacer(floor(PI*scaleByMapSize(10,20)*scaleByMapSize(10,20)/4), 0.95, 0.6, 10, fractionToTiles(0.5 + 0.49*cos(tang)), fractionToTiles(0.5 + 0.49*sin(tang)));
var painter = new LayeredPainter(
[tShore, tWater, tWater], // terrains
[1, 3] // widths);
);
var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -3, 3);
createArea(placer, [painter, elevationPainter], avoidClasses(clPlayer, 23));
}
}
let point = getTIPIADBON(
[fractionToTiles(cLocation), fractionToTiles(0.5 + cDistance)],
[fractionToTiles(cLocation), fractionToTiles(0.5 - cDistance)],
[-6, -1.5],
0.5,
4,
0.01);
if (!point)
continue;
if (!createArea(
new PathPlacer(
Math.floor(point[0]),
Math.floor(point[1]),
Math.floor(fractionToTiles(0.5 + 0.49 * Math.cos(tang))),
Math.floor(fractionToTiles(0.5 + 0.49 * Math.sin(tang))),
someRadius,
0.4,
3 * scaleByMapSize(1, 4),
0.1,
0.05),
[
new SmoothElevationPainter(ELEVATION_SET, -4, 4),
paintClass(clWater)
],
avoidClasses(clPlayer, 8, clWater, 3, clShallow, 2)))
continue;
log("Creating small puddles at the map border to ensure players being separated...");
createArea(
new ClumpPlacer(
Math.floor(Math.PI * Math.pow(someRadius / 2, 2)),
0.95,
0.6,
10,
fractionToTiles(0.5 + 0.49 * Math.cos(tang)),
fractionToTiles(0.5 + 0.49 * Math.sin(tang))),
new SmoothElevationPainter(ELEVATION_SET, -3, 3),
avoidClasses(clPlayer, 23));
}
passageMaker(round(fractionToTiles(0.2)), round(fractionToTiles(0.25)), round(fractionToTiles(0.8)), round(fractionToTiles(0.25)), scaleByMapSize(4,8), -2, -2, 2, clShallow, undefined, -4);
passageMaker(round(fractionToTiles(0.2)), round(fractionToTiles(0.75)), round(fractionToTiles(0.8)), round(fractionToTiles(0.75)), scaleByMapSize(4,8), -2, -2, 2, clShallow, undefined, -4);
log("Creating shallows in tributaries...");
for (let z of [0.25, 0.75])
passageMaker(
Math.round(fractionToTiles(0.2)),
Math.round(fractionToTiles(z)),
Math.round(fractionToTiles(0.8)),
Math.round(fractionToTiles(z)),
scaleByMapSize(4, 8),
-2,
-2,
2,
clShallow,
undefined,
-4);
paintTerrainBasedOnHeight(-5, 1, 1, tWater);
paintTerrainBasedOnHeight(1, 3, 1, tShore);
@ -326,8 +353,9 @@ createFood
);
log("Creating straggler trees...");
var types = [oBeech, oPoplar, oApple]; // some variation
createStragglerTrees(types, avoidClasses(clWater, 1, clForest, 1, clHill, 1, clPlayer, 8, clMetal, 6, clRock, 6));
createStragglerTrees(
[oBeech, oPoplar, oApple],
avoidClasses(clWater, 1, clForest, 1, clHill, 1, clPlayer, 8, clMetal, 6, clRock, 6));
setSkySet("cirrus");
setWaterColor(0.114, 0.192, 0.463);

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

@ -221,11 +221,11 @@ var types = [
];
var size = numForest / (scaleByMapSize(4, 12) * numPlayers);
var num = Math.floor(size / types.length);
for (let i = 0; i < types.length; ++i)
for (let type of types)
createAreas(
new ClumpPlacer(numForest / num, 0.1, 0.1, 1),
[
new LayeredPainter(types[i], [2]),
new LayeredPainter(type, [2]),
paintClass(clForest)
],
avoidClasses(

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

@ -15,16 +15,15 @@ const tRoadWild = g_Terrains.roadWild;
const tTier4Terrain = g_Terrains.tier4Terrain;
const tShore = g_Terrains.shore;
const tWater = g_Terrains.water;
let tHill = g_Terrains.hill;
let tDirt = g_Terrains.dirt;
var tHill = g_Terrains.hill;
var tDirt = g_Terrains.dirt;
if (currentBiome() == "temperate")
{
tDirt = ["medit_shrubs_a", "grass_field"];
tHill = ["grass_field", "peat_temp"];
}
// Gaia entities
const oTree1 = g_Gaia.tree1;
const oTree2 = g_Gaia.tree2;
const oTree3 = g_Gaia.tree3;
@ -37,7 +36,6 @@ const oSecondaryHuntableAnimal = g_Gaia.secondaryHuntableAnimal;
const oStoneLarge = g_Gaia.stoneLarge;
const oMetalLarge = g_Gaia.metalLarge;
// Decorative props
const aGrass = g_Decoratives.grass;
const aGrassShort = g_Decoratives.grassShort;
const aRockLarge = g_Decoratives.rockLarge;
@ -51,46 +49,40 @@ const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TE
InitMap();
const radius = scaleByMapSize(15, 25);
const elevation = 2;
const shoreRadius = 6;
const clPlayer = createTileClass();
const clHill = createTileClass();
const clMountain = createTileClass();
const clForest = createTileClass();
const clWater = createTileClass();
const clDirt = createTileClass();
const clRock = createTileClass();
const clMetal = createTileClass();
const clFood = createTileClass();
const clBaseResource = createTileClass();
const numPlayers = getNumPlayers();
const mapSize = getMapSize();
const mapArea = mapSize * mapSize;
const centerOfMap = mapSize / 2;
let clPlayer = createTileClass();
let clHill = createTileClass();
let clMountain = createTileClass();
let clForest = createTileClass();
let clWater = createTileClass();
let clDirt = createTileClass();
let clRock = createTileClass();
let clMetal = createTileClass();
let clFood = createTileClass();
let clBaseResource = createTileClass();
const landHeight = 2;
const waterHeight = getMapBaseHeight();
const shoreRadius = 6;
initTerrain(tWater);
log("Creating the water...");
createArea(
new ClumpPlacer(getMapArea(), 1, 1, 1, Math.round(fractionToTiles(0.5)), Math.round(fractionToTiles(0.5))),
[
new LayeredPainter([tWater, tWater, tShore], [1, 4]),
new SmoothElevationPainter(ELEVATION_SET, waterHeight, 2),
paintClass(clWater)
],
avoidClasses(clPlayer, 5));
var [playerIDs, playerX, playerZ] = radialPlayerPlacement(0.38);
let fx = fractionToTiles(0.5);
let fz = fractionToTiles(0.5);
let ix = round(fx);
let iz = round(fz);
// Create the water
let placer = new ClumpPlacer(mapArea * 1, 1, 1, 1, ix, iz);
let terrainPainter = new LayeredPainter(
[tWater, tWater, tShore], // terrains
[1, 4] // widths
);
let elevationPainter = new SmoothElevationPainter(
ELEVATION_SET, // type
getMapBaseHeight(), // elevation
2 // blend radius
);
createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 5));
log("Creating player islands...")
for (let i = 0; i < numPlayers; ++i)
{
let id = playerIDs[i];
@ -104,18 +96,20 @@ for (let i = 0; i < numPlayers; ++i)
let hillSize = PI * radius * radius * 2;
// Create the hill
let placer = new ClumpPlacer(hillSize, 0.80, 0.1, 10, ix, iz);
let terrainPainter = new LayeredPainter(
[tShore, tMainTerrain], // terrains
[shoreRadius] // widths
);
let elevationPainter = new SmoothElevationPainter(
ELEVATION_SET, // type
elevation, // elevation
shoreRadius // blend radius
);
createArea(placer, [terrainPainter, elevationPainter, paintClass(clHill)], null);
createArea(
new ClumpPlacer(
hillSize,
0.8,
0.1,
10,
Math.round(fractionToTiles(playerX[i])),
Math.round(fractionToTiles(playerZ[i]))),
[
new LayeredPainter([tShore, tMainTerrain], [shoreRadius]),
new SmoothElevationPainter(ELEVATION_SET, landHeight, shoreRadius),
paintClass(clHill)
],
null);
addCivicCenterAreaToClass(ix, iz, clPlayer);
@ -123,7 +117,7 @@ for (let i = 0; i < numPlayers; ++i)
// Create the city patch
let cityRadius = radius/3;
placer = new ClumpPlacer(PI * cityRadius * cityRadius, 0.6, 0.3, 10, ix, iz);
let placer = new ClumpPlacer(PI * cityRadius * cityRadius, 0.6, 0.3, 10, ix, iz);
let painter = new LayeredPainter([tRoadWild, tRoad], [1]);
createArea(placer, painter, null);
@ -186,95 +180,104 @@ for (let i = 0; i < numPlayers; ++i)
RMS.SetProgress(40);
// Create central island
placer = new ChainPlacer(floor(scaleByMapSize(6, 6)), floor(scaleByMapSize(10, 15)), floor(scaleByMapSize(200, 300)), 1, centerOfMap, centerOfMap, 0, [floor(mapSize * 0.01)]);
terrainPainter = new LayeredPainter(
[tShore, tMainTerrain], // terrains
[shoreRadius, 100] // widths
);
elevationPainter = new SmoothElevationPainter(
ELEVATION_SET, // type
elevation, // elevation
shoreRadius // blend radius
);
createArea(placer, [terrainPainter, elevationPainter, paintClass(clHill)], avoidClasses(clPlayer, 40));
log("Creating central island...");
createArea(
new ChainPlacer(
6,
Math.floor(scaleByMapSize(10, 15)),
Math.floor(scaleByMapSize(200, 300)),
1,
centerOfMap,
centerOfMap,
0,
[Math.floor(mapSize * 0.01)]),
[
new LayeredPainter([tShore, tMainTerrain], [shoreRadius, 100]),
new SmoothElevationPainter(ELEVATION_SET, landHeight, shoreRadius),
paintClass(clHill)
],
avoidClasses(clPlayer, 40));
for (let m = 0; m < randIntInclusive(20, 34); ++m)
{
let placer = new ChainPlacer(
Math.floor(scaleByMapSize(7, 7)),
Math.floor(scaleByMapSize(15, 15)),
Math.floor(scaleByMapSize(15, 20)),
1,
randIntExclusive(0, mapSize),
randIntExclusive(0, mapSize),
0,
[Math.floor(mapSize * 0.01)]);
let elevRand = randIntInclusive(6, 20);
let terrainPainter = new LayeredPainter(
[tDirt, tHill], // terrains
[floor(elevRand / 3), 40] // widths
);
let elevationPainter = new SmoothElevationPainter(
ELEVATION_SET, // type
elevRand, // elevation
floor(elevRand / 3) // blend radius
);
createArea(placer, [terrainPainter, elevationPainter, paintClass(clHill)], [avoidClasses(clBaseResource, 2, clPlayer, 40), stayClasses(clHill, 6)]);
createArea(
new ChainPlacer(
7,
15,
Math.floor(scaleByMapSize(15, 20)),
1,
randIntExclusive(0, mapSize),
randIntExclusive(0, mapSize),
0,
[Math.floor(mapSize * 0.01)]),
[
new LayeredPainter([tDirt, tHill], [Math.floor(elevRand / 3), 40]),
new SmoothElevationPainter(ELEVATION_SET, elevRand, Math.floor(elevRand / 3)),
paintClass(clHill)
],
[avoidClasses(clBaseResource, 2, clPlayer, 40), stayClasses(clHill, 6)]);
}
for (let m = 0; m < randIntInclusive(8, 17); ++m)
{
let placer = new ChainPlacer(
Math.floor(scaleByMapSize(5, 5)),
Math.floor(scaleByMapSize(8, 8)),
Math.floor(scaleByMapSize(15, 20)),
1,
randIntExclusive(0, mapSize),
randIntExclusive(0, mapSize),
0,
[Math.floor(mapSize * 0.01)]);
let elevRand = randIntInclusive(15, 29);
let terrainPainter = new LayeredPainter(
[tCliff, tForestFloor2], // terrains
[floor(elevRand / 3), 40] // widths
);
let elevationPainter = new SmoothElevationPainter(
ELEVATION_MODIFY, // type
elevRand, // elevation
floor(elevRand / 3) // blend radius
);
createArea(placer, [terrainPainter, elevationPainter, paintClass(clMountain)], [avoidClasses(clBaseResource, 2, clPlayer, 40), stayClasses(clHill, 6)]);
createArea(
new ChainPlacer(
5,
8,
Math.floor(scaleByMapSize(15, 20)),
1,
randIntExclusive(0, mapSize),
randIntExclusive(0, mapSize),
0,
[Math.floor(mapSize * 0.01)]),
[
new LayeredPainter([tCliff, tForestFloor2], [Math.floor(elevRand / 3), 40]),
new SmoothElevationPainter(ELEVATION_MODIFY, elevRand, Math.floor(elevRand / 3)),
paintClass(clMountain)
],
[avoidClasses(clBaseResource, 2, clPlayer, 40), stayClasses(clHill, 6)]);
}
// Create center bounty
let group = new SimpleGroup(
[new SimpleObject(oMetalLarge, 3, 6, 25, floor(mapSize * 0.25))],
true, clBaseResource, centerOfMap, centerOfMap
);
createObjectGroup(group, 0, [avoidClasses(clBaseResource, 20, clPlayer, 40, clMountain, 4), stayClasses(clHill, 10)]);
group = new SimpleGroup(
[new SimpleObject(oStoneLarge, 3, 6, 25, floor(mapSize * 0.25))],
true, clBaseResource, centerOfMap, centerOfMap
);
createObjectGroup(group, 0, [avoidClasses(clBaseResource, 20, clPlayer, 40, clMountain, 4), stayClasses(clHill, 10)]);
group = new SimpleGroup(
[new SimpleObject(oMainHuntableAnimal, floor(6 * numPlayers), floor(6 * numPlayers), 2, floor(mapSize * 0.1))],
true, clBaseResource, centerOfMap, centerOfMap
);
createObjectGroup(group, 0, [avoidClasses(clBaseResource, 2, clMountain, 4, clPlayer, 40, clWater, 2), stayClasses(clHill, 10)]);
log("Creating center bounty...");
createObjectGroup(
new SimpleGroup(
[new SimpleObject(oMetalLarge, 3, 6, 25, Math.floor(mapSize * 0.25))],
true,
clBaseResource,
centerOfMap,
centerOfMap),
0,
[avoidClasses(clBaseResource, 20, clPlayer, 40, clMountain, 4), stayClasses(clHill, 10)]);
createObjectGroup(
new SimpleGroup(
[new SimpleObject(oStoneLarge, 3, 6, 25, Math.floor(mapSize * 0.25))],
true,
clBaseResource,
centerOfMap,
centerOfMap),
0,
[avoidClasses(clBaseResource, 20, clPlayer, 40, clMountain, 4), stayClasses(clHill, 10)]);
createObjectGroup(
new SimpleGroup(
[new SimpleObject(oMainHuntableAnimal, Math.floor(6 * numPlayers), Math.floor(6 * numPlayers), 2, Math.floor(mapSize * 0.1))],
true,
clBaseResource,
centerOfMap,
centerOfMap),
0,
[avoidClasses(clBaseResource, 2, clMountain, 4, clPlayer, 40, clWater, 2), stayClasses(clHill, 10)]);
log("Creating fish...");
group = new SimpleGroup(
[new SimpleObject(oFish, 2, 3, 0, 2)],
true, clFood
);
createObjectGroupsDeprecated(group, 0,
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(oFish, 2, 3, 0, 2)], true, clFood),
0,
avoidClasses(clHill, 10, clFood, 20),
10 * numPlayers, 60
);
10 * numPlayers,
60);
createForests(
[tMainTerrain, tForestFloor1, tForestFloor2, pForest1, pForest2],
@ -290,41 +293,28 @@ createStragglerTrees(types, [avoidClasses(clBaseResource, 2, clMetal, 6, clRock,
RMS.SetProgress(65);
log("Creating dirt patches...");
let sizes = [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)];
let numb = currentBiome() == "savanna" ? 3 : 1;
for (let i = 0; i < sizes.length; ++i)
{
placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
let painter = new LayeredPainter(
[[tMainTerrain, tTier1Terrain], [tTier1Terrain, tTier2Terrain], [tTier2Terrain, tTier3Terrain]], // terrains
[1, 1] // widths
);
var numb = currentBiome() == "savanna" ? 3 : 1;
for (let size of [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)])
createAreas(
placer,
[painter, paintClass(clDirt)],
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
[
new LayeredPainter([[tMainTerrain, tTier1Terrain], [tTier1Terrain, tTier2Terrain], [tTier2Terrain, tTier3Terrain]], [1, 1]),
paintClass(clDirt)
],
avoidClasses(clForest, 0, clMountain, 0, clDirt, 5, clPlayer, 10),
numb * scaleByMapSize(15, 45)
);
}
numb * scaleByMapSize(15, 45));
log("Painting shorelines...");
paintTerrainBasedOnHeight(1, 2, 0, tMainTerrain);
paintTerrainBasedOnHeight(getMapBaseHeight(), 1, 3, tTier1Terrain);
paintTerrainBasedOnHeight(1, landHeight, 0, tMainTerrain);
paintTerrainBasedOnHeight(waterHeight, 1, 3, tTier1Terrain);
log("Creating grass patches...");
sizes = [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)];
for (let i = 0; i < sizes.length; ++i)
{
placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
let painter = new TerrainPainter(tTier4Terrain);
for (let size of [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)])
createAreas(
placer,
painter,
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
new TerrainPainter(tTier4Terrain),
avoidClasses(clForest, 0, clMountain, 0, clDirt, 5, clPlayer, 10),
numb * scaleByMapSize(15, 45)
);
}
numb * scaleByMapSize(15, 45));
log("Creating food...");
createFood(
@ -352,9 +342,8 @@ log("Creating more straggeler trees...");
createStragglerTrees(types, avoidClasses(clWater, 5, clForest, 7, clMountain, 1, clPlayer, 30, clMetal, 6, clRock, 3));
log("Creating decoration...");
let planetm = currentBiome() == "tropic" ? 8 : 1;
createDecoration
(
var planetm = currentBiome() == "tropic" ? 8 : 1;
createDecoration(
[
[new SimpleObject(aRockMedium, 1, 3, 0, 1)],
[new SimpleObject(aRockLarge, 1, 2, 0, 1), new SimpleObject(aRockMedium, 1, 3, 0, 2)],
@ -369,8 +358,7 @@ createDecoration
planetm * scaleByMapSize(13, 200),
planetm * scaleByMapSize(13, 200)
],
avoidClasses(clForest, 2, clPlayer, 20, clMountain, 5, clFood, 1, clBaseResource, 2)
);
avoidClasses(clForest, 2, clPlayer, 20, clMountain, 5, clFood, 1, clBaseResource, 2));
log("Creating water forests...");
createForests(
@ -381,13 +369,11 @@ createForests(
...rBiomeTreeCount(0.1));
log("Creating small grass tufts...");
group = new SimpleGroup(
[new SimpleObject(aGrassShort, 1, 2, 0, 1, -PI / 8, PI / 8)]
);
createObjectGroupsDeprecated(group, 0,
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(aGrassShort, 1, 2, 0, 1)]),
0,
[avoidClasses(clMountain, 2, clPlayer, 2, clDirt, 0), stayClasses(clHill, 8)],
planetm * scaleByMapSize(13, 200)
);
planetm * scaleByMapSize(13, 200));
setSkySet(pickRandom(["cloudless", "cumulus", "overcast"]));
setWaterMurkiness(0.4);

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

@ -159,29 +159,26 @@ for (var i=0; i < numPlayers; i++)
log("Creating lakes...");
var numLakes = round(scaleByMapSize(1,4) * numPlayers);
var placer = new ClumpPlacer(scaleByMapSize(100,250), 0.8, 0.1, 10);
var terrainPainter = new LayeredPainter(
[tShore, tWater, tWater], // terrains
[1,1] // widths
);
var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -4, 3);
var waterAreas = createAreas(
placer,
[terrainPainter, elevationPainter, paintClass(clWater)],
new ClumpPlacer(scaleByMapSize(100,250), 0.8, 0.1, 10),
[
new LayeredPainter([tShore, tWater, tWater], [1, 1]),
new SmoothElevationPainter(ELEVATION_SET, -4, 3),
paintClass(clWater)
],
avoidClasses(clPlayer, 7, clWater, 20),
numLakes
);
numLakes);
RMS.SetProgress(15);
log("Creating reeds...");
group = new SimpleGroup(
[new SimpleObject(aReeds, 5,10, 0,4), new SimpleObject(aLillies, 0,1, 0,4)], true
);
createObjectGroupsByAreasDeprecated(group, 0,
createObjectGroupsByAreasDeprecated(
new SimpleGroup([new SimpleObject(aReeds, 5,10, 0,4), new SimpleObject(aLillies, 0,1, 0,4)], true),
0,
[borderClasses(clWater, 3, 0), stayClasses(clWater, 1)],
numLakes, 100,
waterAreas
);
waterAreas);
RMS.SetProgress(25);
log("Creating fish...");
@ -194,8 +191,7 @@ createObjectGroupsByAreasDeprecated(
[stayClasses(clWater, 4), avoidClasses(clFood, 8)],
numLakes / 4,
50,
waterAreas
);
waterAreas);
RMS.SetProgress(30);
createBumps(avoidClasses(clWater, 2, clPlayer, 5));
@ -219,23 +215,18 @@ var types = [
[[tForestFloor, tGrass, pForestD], [tForestFloor, pForestD]],
[[tForestFloor, tGrass, pForestO], [tForestFloor, pForestO]],
[[tForestFloor, tGrass, pForestP], [tForestFloor, pForestP]]
]; // some variation
];
var size = numForest / (scaleByMapSize(3,6) * numPlayers);
var num = floor(size / types.length);
for (var i = 0; i < types.length; ++i)
{
placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), numForest / num, 0.5);
var painter = new LayeredPainter(
types[i], // terrains
[2] // widths
);
for (let type of types)
createAreas(
placer,
[painter, paintClass(clForest)],
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), numForest / num, 0.5),
[
new LayeredPainter(type, [2]),
paintClass(clForest)
],
avoidClasses(clPlayer, 5, clWater, 3, clForest, 15, clHill, 1),
num
);
}
num);
RMS.SetProgress(50);
log("Creating dirt patches...");
@ -322,8 +313,9 @@ createFood
RMS.SetProgress(90);
log("Creating straggler trees...");
var types = [oOak, oBeech, oPine]; // some variation
createStragglerTrees(types, avoidClasses(clWater, 1, clForest, 1, clHill, 1, clPlayer, 1, clMetal, 6, clRock, 6));
createStragglerTrees(
[oOak, oBeech, oPine],
avoidClasses(clWater, 1, clForest, 1, clHill, 1, clPlayer, 1, clMetal, 6, clRock, 6));
RMS.SetProgress(95);
setSkySet("sunny");

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

@ -48,8 +48,6 @@ const numPlayers = getNumPlayers();
const mapSize = getMapSize();
const mapArea = mapSize*mapSize;
log(mapSize);
var clPlayer = createTileClass();
var clHill = createTileClass();
var clForest = createTileClass();
@ -62,25 +60,6 @@ var clBaseResource = createTileClass();
initTerrain(tMainTerrain);
var fx = fractionToTiles(0.5);
var fz = fractionToTiles(0.5);
var ix = round(fx);
var iz = round(fz);
var lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 8))));
var placer = new ClumpPlacer(mapArea * 0.23, 1, 1, 10, ix, iz);
var terrainPainter = new LayeredPainter(
[tShore, tWater, tWater, tWater], // terrains
[1, 4, 2] // widths
);
var elevationPainter = new SmoothElevationPainter(
ELEVATION_SET, // type
-3, // elevation
4 // blend radius
);
createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], null);
var [playerIDs, playerX, playerZ, playerAngle, startAngle] = radialPlayerPlacement();
for (var i = 0; i < numPlayers; i++)
@ -201,106 +180,77 @@ else if (mapSize == 448)
split = 2;
}
log ("Creating rivers...");
for (var m = 0; m < numPlayers*split; m++)
{
var tang = startAngle + (m+0.5)*TWO_PI/(numPlayers*split);
var placer = new PathPlacer(fractionToTiles(0.5 + 0.15*cos(tang)), fractionToTiles(0.5 + 0.15*sin(tang)), fractionToTiles(0.5 + 0.49*cos(tang)), fractionToTiles(0.5 + 0.49*sin(tang)), scaleByMapSize(14,40), 0.0, 3*(scaleByMapSize(1,3)), 0.2, 0.05);
var terrainPainter = new LayeredPainter(
[tShore, tWater, tWater], // terrains
[1, 3] // widths
);
var elevationPainter = new SmoothElevationPainter(
ELEVATION_SET, // type
-4, // elevation
4 // blend radius
);
createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 5));
placer = new ClumpPlacer(floor(PI*scaleByMapSize(14,40)*scaleByMapSize(14,40)/4), 1, 0, 10, fractionToTiles(0.5 + 0.49*cos(tang)), fractionToTiles(0.5 + 0.49*sin(tang)));
var painter = new LayeredPainter([tWater, tWater], [1]);
var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -4, 4);
createArea(placer, [painter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 5));
log ("Creating big circular lake...");
var center = Math.round(fractionToTiles(0.5));
createArea(
new ClumpPlacer(mapArea * 0.23, 1, 1, 10, center, center),
new SmoothElevationPainter(ELEVATION_SET, -3, 4),
null);
var tang = startAngle + (m)*TWO_PI/(numPlayers*split);
var placer = new PathPlacer(fractionToTiles(0.5 + 0.05*cos(tang)), fractionToTiles(0.5 + 0.05*sin(tang)), fractionToTiles(0.5 + 0.49*cos(tang)), fractionToTiles(0.5 + 0.49*sin(tang)), scaleByMapSize(10,40), 0.0, 3*(scaleByMapSize(1,3)), 0.2, 0.05);
var terrainPainter = new LayeredPainter(
[tWater, tShore, tMainTerrain], // terrains
[1, 3] // widths
);
var elevationPainter = new SmoothElevationPainter(
ELEVATION_SET, // type
3, // elevation
4 // blend radius
);
createArea(placer, [terrainPainter, elevationPainter], null);
for (let m = 0; m < numPlayers * split; ++m)
{
log("Creating rivers between players...");
let angle = startAngle + (m + 0.5) * 2 * Math.PI / (numPlayers * split);
createArea(
new PathPlacer(
fractionToTiles(0.5 + 0.15 * Math.cos(angle)),
fractionToTiles(0.5 + 0.15 * Math.sin(angle)),
fractionToTiles(0.5 + 0.6 * Math.cos(angle)),
fractionToTiles(0.5 + 0.6 * Math.sin(angle)),
scaleByMapSize(14, 40),
0,
3 * scaleByMapSize(1, 3),
0.2,
0.05),
new SmoothElevationPainter(ELEVATION_SET, -4, 4),
avoidClasses(clPlayer, 5));
log("Create path from the island to the center...");
angle = startAngle + m * 2 * Math.PI / (numPlayers * split);
createArea(
new PathPlacer(
fractionToTiles(0.5 + 0.05 * Math.cos(angle)),
fractionToTiles(0.5 + 0.05 * Math.sin(angle)),
fractionToTiles(0.5 + 0.49 * Math.cos(angle)),
fractionToTiles(0.5 + 0.49 * Math.sin(angle)),
scaleByMapSize(10, 40),
0,
3 * scaleByMapSize(1, 3),
0.2,
0.05),
new SmoothElevationPainter(ELEVATION_SET, 3, 4),
null);
}
var fx = fractionToTiles(0.5);
var fz = fractionToTiles(0.5);
ix = round(fx);
iz = round(fz);
log("Creating ring of land connecting players...");
createArea(
new ClumpPlacer(mapArea * 0.15, 1, 1, 10, center, center),
new SmoothElevationPainter(ELEVATION_SET, 4, 4),
null);
var placer = new ClumpPlacer(mapArea * 0.15, 1, 1, 10, ix, iz);
var terrainPainter = new LayeredPainter(
[tShore, tWater, tWater, tWater], // terrains
[1, 4, 2] // widths
);
var elevationPainter = new SmoothElevationPainter(
ELEVATION_SET, // type
4, // elevation
4 // blend radius
);
createArea(placer, [terrainPainter, elevationPainter, unPaintClass(clWater)], null);
log("Creating ring of water separating the central hill from the ring...");
createArea(
new ClumpPlacer(mapArea * 0.09, 1, 1, 10, center, center),
new SmoothElevationPainter(ELEVATION_SET, -2, 3),
null);
var fx = fractionToTiles(0.5);
var fz = fractionToTiles(0.5);
ix = round(fx);
iz = round(fz);
log("Creating central island...");
createArea(
new ClumpPlacer(Math.pow(mapSize - 50, 2) * 0.09, 1, 1, 10, center, center),
new SmoothElevationPainter(ELEVATION_SET, 4, 3),
null);
var lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 8))));
var placer = new ClumpPlacer(mapArea * 0.09, 1, 1, 10, ix, iz);
var terrainPainter = new LayeredPainter(
[tShore, tWater, tWater], // terrains
[1, 3] // widths
);
var elevationPainter = new SmoothElevationPainter(
ELEVATION_SET, // type
-2, // elevation
3 // blend radius
);
createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], null);
var placer = new ClumpPlacer((mapSize - 50) * (mapSize - 50) * 0.09, 1, 1, 10, ix, iz);
var terrainPainter = new LayeredPainter(
[tShore, tWater, tWater, tWater], // terrains
[1, 4, 2] // widths
);
var elevationPainter = new SmoothElevationPainter(
ELEVATION_SET, // type
4, // elevation
3 // blend radius
);
createArea(placer, [terrainPainter, elevationPainter, unPaintClass(clWater)], null);
var placer = new ClumpPlacer(scaleByMapSize(6, 18)*scaleByMapSize(6, 18)*22, 1, 1, 10, ix, iz);
var terrainPainter = new LayeredPainter(
[tMainTerrain, tMainTerrain], // terrains
[1] // widths
);
var elevationPainter = new SmoothElevationPainter(
ELEVATION_SET, // type
20, // elevation
8 // blend radius
);
createArea(placer, [terrainPainter, elevationPainter], null);
log("Creating hill on the central island...");
createArea(
new ClumpPlacer(Math.pow(scaleByMapSize(6, 18), 2) * 22, 1, 1, 10, center, center),
new SmoothElevationPainter(ELEVATION_SET, 20, 8),
null);
paintTerrainBasedOnHeight(-6, 1, 1, tWater);
paintTerrainBasedOnHeight(1, 2, 1, tShore);
paintTerrainBasedOnHeight(2, 5, 1, tMainTerrain);
paintTerrainBasedOnHeight(2, 21, 1, tMainTerrain);
paintTileClassBasedOnHeight(-6, 0.5, 1, clWater);
unPaintTileClassBasedOnHeight(0.5, 10, 1, clWater);
for (var i = 0; i < numPlayers; i++)
{
@ -424,7 +374,8 @@ createFood
avoidClasses(clWater, 3, clForest, 0, clPlayer, 20, clHill, 1, clFood, 10)
);
var types = [oTree1, oTree2, oTree4, oTree3]; // some variation
createStragglerTrees(types, avoidClasses(clWater, 5, clForest, 7, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6));
createStragglerTrees(
[oTree1, oTree2, oTree4, oTree3],
avoidClasses(clWater, 5, clForest, 7, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6));
ExportMap();

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

@ -314,8 +314,9 @@ createFood
RMS.SetProgress(85);
log("Creating straggler trees...");
var types = [oPoplar, oCarob, oApple]; // some variation
createStragglerTrees(types, [avoidClasses(clForest, 1, clHill, 1, clPlayer, 9, clMetal, 6, clRock, 6, clRiver, 1), stayClasses(clLand, 7)]);
createStragglerTrees(
[oPoplar, oCarob, oApple],
[avoidClasses(clForest, 1, clHill, 1, clPlayer, 9, clMetal, 6, clRock, 6, clRiver, 1), stayClasses(clLand, 7)]);
setSkySet("cumulus");
setWaterColor(0.2,0.312,0.522);

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

@ -23,7 +23,6 @@ if (random_terrain == 1)
var tShore = "alpine_shore_rocks_grass_50";
var tWater = "alpine_shore_rocks";
// gaia entities
var oPine = "gaia/flora_tree_pine";
var oBerryBush = "gaia/flora_bush_berry";
var oDeer = "gaia/fauna_deer";
@ -33,7 +32,6 @@ if (random_terrain == 1)
var oStoneSmall = "gaia/geology_stone_alpine_a";
var oMetalLarge = "gaia/geology_metal_alpine_slabs";
// decorative props
var aGrass = "actor|props/flora/grass_soft_small_tall.xml";
var aGrassShort = "actor|props/flora/grass_soft_large.xml";
var aRockLarge = "actor|geology/stone_granite_med.xml";
@ -59,7 +57,6 @@ else if (random_terrain == 2)
var tShore = "alpine_shore_rocks_icy";
var tWater = "alpine_shore_rocks";
// gaia entities
var oPine = "gaia/flora_tree_pine_w";
var oBerryBush = "gaia/flora_bush_berry";
var oDeer = "gaia/fauna_deer";
@ -69,7 +66,6 @@ else if (random_terrain == 2)
var oStoneSmall = "gaia/geology_stone_alpine_a";
var oMetalLarge = "gaia/geology_metal_alpine_slabs";
// decorative props
var aGrass = "actor|props/flora/grass_soft_dry_small_tall.xml";
var aGrassShort = "actor|props/flora/grass_soft_dry_large.xml";
var aRockLarge = "actor|geology/stone_granite_med.xml";
@ -95,7 +91,6 @@ else
var tShore = "polar_ice_snow";
var tWater = ["polar_ice_snow", "polar_ice"];
// gaia entities
var oPine = "gaia/flora_tree_pine_w";
var oBerryBush = "gaia/flora_bush_berry";
var oDeer = "gaia/fauna_deer";
@ -105,7 +100,6 @@ else
var oStoneSmall = "gaia/geology_stone_alpine_a";
var oMetalLarge = "gaia/geology_metal_alpine_slabs";
// decorative props
var aGrass = "actor|props/flora/grass_soft_dry_small_tall.xml";
var aGrassShort = "actor|props/flora/grass_soft_dry_large.xml";
var aRockLarge = "actor|geology/stone_granite_med.xml";
@ -134,20 +128,17 @@ var clBaseResource = createTileClass();
initTerrain(tPrimary);
var playerIDs = sortAllPlayers();
var playerX = [];
var playerZ = [];
var playerAngle = [];
var startAngle = -Math.PI / 6;
var startAngle = -PI/6;
for (var i = 0; i < numPlayers; i++)
for (let i = 0; i < numPlayers; ++i)
{
if (numPlayers == 1)
playerAngle[i] = startAngle + TWO_PI/3;
else
playerAngle[i] = startAngle + i*TWO_PI/(numPlayers-1)*2/3;
playerX[i] = 0.5 + 0.35*cos(playerAngle[i]);
playerZ[i] = 0.5 + 0.35*sin(playerAngle[i]);
let playerAngle = startAngle + 2/3 * Math.PI *
(numPlayers == 1 ? 1 : 2 * i / (numPlayers - 1));
playerX[i] = 0.5 + 0.35 * Math.cos(playerAngle);
playerZ[i] = 0.5 + 0.35 * Math.sin(playerAngle);
}
for (var i = 0; i < numPlayers; i++)
@ -229,80 +220,33 @@ for (var i = 0; i < numPlayers; i++)
RMS.SetProgress(20);
//create the gulf
log("Creating the gulf...");
var seaHeight = random_terrain == 3 ? 0 : -3;
if (random_terrain == 3)
{
var seaHeight = 0;
}
else
{
var seaHeight = -3;
}
var lSize = Math.pow(scaleByMapSize(1, 6), 1/8);
var gulfLocations = [
[200, Math.round(fractionToTiles(0.5)), 0.17],
[120, Math.round(fractionToTiles(0.3)), 0.18 * lSize],
[100, 1, 0.19 * lSize]
];
//create the upper part
var fx = fractionToTiles(0.5);
var fz = fractionToTiles(0.5);
ix = round(fx);
iz = round(fz);
var lSize = 1;
var placer = new ChainPlacer(2, floor(scaleByMapSize(5, 16)), floor(scaleByMapSize(35, 200)), 1, ix, iz, 0, [floor(mapSize * 0.17 * lSize)]);
var terrainPainter = new LayeredPainter(
[tPrimary, tPrimary, tPrimary, tPrimary], // terrains
[1, 4, 2] // widths
);
var elevationPainter = new SmoothElevationPainter(
ELEVATION_SET, // type
seaHeight, // elevation
4 // blend radius
);
createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer,scaleByMapSize(20,28)));
//the middle part
var fx = fractionToTiles(0.5);
var fz = fractionToTiles(0.3);
ix = round(fx);
iz = round(fz);
var lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 6))));
var placer = new ChainPlacer(2, floor(scaleByMapSize(5, 16)), floor(scaleByMapSize(35, 120)), 1, ix, iz, 0, [floor(mapSize * 0.18 * lSize)]);
var terrainPainter = new LayeredPainter(
[tPrimary, tPrimary, tPrimary, tPrimary], // terrains
[1, 4, 2] // widths
);
var elevationPainter = new SmoothElevationPainter(
ELEVATION_SET, // type
seaHeight, // elevation
4 // blend radius
);
createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer,scaleByMapSize(20,28)));
//the lower part
var fx = fractionToTiles(0.5);
var fz = 0;
ix = round(fx);
iz = round(fz)+1;
var lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 6))));
var placer = new ChainPlacer(2, floor(scaleByMapSize(5, 16)), floor(scaleByMapSize(35, 100)), 1, ix, iz, 0, [floor(mapSize * 0.19 * lSize)]);
var terrainPainter = new LayeredPainter(
[tPrimary, tPrimary, tPrimary, tPrimary], // terrains
[1, 4, 2] // widths
);
var elevationPainter = new SmoothElevationPainter(
ELEVATION_SET, // type
seaHeight, // elevation
4 // blend radius
);
createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer,scaleByMapSize(20,28)));
for (let [numCircles, z, firstRadius] of gulfLocations)
createArea(
new ChainPlacer(
2,
Math.floor(scaleByMapSize(5, 16)),
Math.floor(scaleByMapSize(35, numCircles)),
1,
Math.round(fractionToTiles(0.5)),
z,
0,
[Math.floor(mapSize * firstRadius)]),
[
new LayeredPainter([tPrimary, tPrimary, tPrimary, tPrimary], [1, 4, 2]),
new SmoothElevationPainter(ELEVATION_SET, seaHeight, 4),
paintClass(clWater)
],
avoidClasses(clPlayer,scaleByMapSize(20, 28)));
if (random_terrain == 3)
{
@ -326,7 +270,7 @@ createForests(
[tPrimary, tForestFloor, tForestFloor, pForest, pForest],
avoidClasses(clPlayer, 20, clForest, 16, clHill, 0, clWater, 2),
clForest,
1.0);
1);
RMS.SetProgress(60);
@ -367,27 +311,23 @@ createMines(
RMS.SetProgress(70);
var multiplier = 0;
if (random_terrain !== 3) multiplier = 1;
createDecoration
(
[[new SimpleObject(aRockMedium, 1,3, 0,1)],
[new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
[new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)],
[new SimpleObject(aGrass, 2,4, 0,1.8, -PI/8,PI/8), new SimpleObject(aGrassShort, 3,6, 1.2,2.5, -PI/8,PI/8)],
[new SimpleObject(aBushMedium, 1,2, 0,2), new SimpleObject(aBushSmall, 2,4, 0,2)]
],
[
scaleByMapSize(16, 262),
scaleByMapSize(8, 131),
multiplier * scaleByMapSize(13, 200),
multiplier * scaleByMapSize(13, 200),
multiplier * scaleByMapSize(13, 200)
],
avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0)
);
var multiplier = random_terrain == 3 ? 0 : 1;
createDecoration(
[
[new SimpleObject(aRockMedium, 1, 3, 0, 1)],
[new SimpleObject(aRockLarge, 1, 2, 0, 1), new SimpleObject(aRockMedium, 1, 3, 0, 2)],
[new SimpleObject(aGrassShort, 1, 2, 0, 1)],
[new SimpleObject(aGrass, 2, 4, 0, 1.8), new SimpleObject(aGrassShort, 3, 6, 1.2, 2.5)],
[new SimpleObject(aBushMedium, 1, 2, 0, 2), new SimpleObject(aBushSmall, 2, 4, 0, 2)]
],
[
scaleByMapSize(16, 262),
scaleByMapSize(8, 131),
multiplier * scaleByMapSize(13, 200),
multiplier * scaleByMapSize(13, 200),
multiplier * scaleByMapSize(13, 200)
],
avoidClasses(clWater, 0, clForest, 0, clPlayer, 5, clHill, 0, clBaseResource, 5));
RMS.SetProgress(75);
createFood

4
binaries/data/mods/public/maps/random/harbor.js
View file

@ -253,7 +253,6 @@ ExportMap();
function addCenterLake()
{
let lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 6))));
let center = Math.round(fractionToTiles(0.5));
createArea(
@ -265,8 +264,7 @@ function addCenterLake()
center,
center,
0,
[Math.floor(mapSize * 0.17 * lSize)]
),
[Math.floor(mapSize * 0.17 * Math.pow(scaleByMapSize(1, 6), 1/8))]),
[
new LayeredPainter(
[

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

@ -34,7 +34,6 @@ const aRockMedium = "actor|geology/stone_granite_med.xml";
const aBushMedium = "actor|props/flora/bush_medit_me_lush.xml";
const aBushSmall = "actor|props/flora/bush_medit_sm_lush.xml";
// terrain + entity (for painting)
const pForestD = [tGrassDForest + TERRAIN_SEPARATOR + oPoplar, tGrassDForest];
const pForestP = [tGrassPForest + TERRAIN_SEPARATOR + oOak, tGrassPForest];
@ -164,46 +163,34 @@ paintRiver({
RMS.SetProgress(20);
log("Creating fish...");
num = scaleByMapSize(10, 20);
for (var i=0; i < num; i++){
group = new SimpleGroup(
[new SimpleObject(oFish, 2,3, 0,2)],
true, clFood
);
createObjectGroupsDeprecated(group, 0,
[stayClasses(clWater, 2), avoidClasses(clFood, 3)],
numPlayers, 50
);
}
for (let i = 0; i < scaleByMapSize(10, 20); ++i)
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(oFish, 2, 3, 0, 2)], true, clFood),
0,
[stayClasses(clWater, 2), avoidClasses(clFood, 3)],
numPlayers,
50);
RMS.SetProgress(25);
log("Creating bumps...");
placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1);
painter = new SmoothElevationPainter(ELEVATION_MODIFY, 4, 3);
createAreas(
placer,
painter,
new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1),
new SmoothElevationPainter(ELEVATION_MODIFY, 4, 3),
stayClasses(clHighlands, 1),
scaleByMapSize(300, 600)
);
scaleByMapSize(300, 600));
RMS.SetProgress(30);
log("Creating hills...");
placer = new ClumpPlacer(scaleByMapSize(20, 150), 0.2, 0.1, 1);
var terrainPainter = new LayeredPainter(
[tCliff, tHill], // terrains
[2] // widths
);
var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 15, 2);
createAreas(
placer,
[terrainPainter, elevationPainter, paintClass(clHill)],
new ClumpPlacer(scaleByMapSize(20, 150), 0.2, 0.1, 1),
[
new LayeredPainter([tCliff, tHill], [2]),
new SmoothElevationPainter(ELEVATION_SET, 15, 2),
paintClass(clHill)
],
avoidClasses(clSea, 5, clPlayer, 20, clWater, 5, clHill, 15, clHighlands, 5),
scaleByMapSize(1, 4) * numPlayers
);
scaleByMapSize(1, 4) * numPlayers);
RMS.SetProgress(35);
@ -219,78 +206,56 @@ var numStragglers = totalTrees * (1.0 - P_FOREST);
log("Creating mainland forests...");
var types = [
[[tGrassDForest, tGrass, pForestD], [tGrassDForest, pForestD]]
]; // some variation
var size = numForest*1.3 / (scaleByMapSize(2,8) * numPlayers);
var num = floor(0.7*size / types.length);
for (var i = 0; i < types.length; ++i)
{
placer = new ClumpPlacer(numForest / num, 0.1, 0.1, 1);
painter = new LayeredPainter(
types[i], // terrains
[2] // widths
);
];
var size = numForest * 1.3 / (scaleByMapSize(2,8) * numPlayers);
var num = Math.floor(0.7 * size / types.length);
for (let type of types)
createAreas(
placer,
[painter, paintClass(clForest)],
new ClumpPlacer(numForest / num, 0.1, 0.1, 1),
[
new LayeredPainter(type, [2]),
paintClass(clForest)
],
avoidClasses(clPlayer, 20, clWater, 3, clForest, 10, clHill, 0, clSea, 6, clBaseResource, 3),
num
);
}
num);
RMS.SetProgress(45);
log("Creating highland forests...");
var types = [
[[tGrassDForest, tGrass, pForestP], [tGrassDForest, pForestP]]
]; // some variation
];
var size = numForest / (scaleByMapSize(2,8) * numPlayers);
var num = floor(size / types.length);
for (var i = 0; i < types.length; ++i)
{
placer = new ClumpPlacer(numForest / num, 0.1, 0.1, 1);
painter = new LayeredPainter(
types[i], // terrains
[2] // widths
);
for (let type of types)
createAreas(
placer,
[painter, paintClass(clForest)],
new ClumpPlacer(numForest / num, 0.1, 0.1, 1),
[
new LayeredPainter(type, [2]),
paintClass(clForest)
],
avoidClasses(clPlayer, 20, clWater, 3, clForest, 2, clHill, 0, clSea, 6, clFlatlands, 3),
num
);
}
num);
RMS.SetProgress(70);
log("Creating dirt patches...");
var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
for (var i = 0; i < sizes.length; i++)
{
placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
painter = new LayeredPainter(
[[tGrass,tGrassA],[tGrassA,tGrassB], [tGrassB,tGrassC]], // terrains
[1,1] // widths
);
for (let size of [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)])
createAreas(
placer,
[painter, paintClass(clDirt)],
new ClumpPlacer(size, 0.3, 0.06, 0.5),
[
new LayeredPainter([[tGrass, tGrassA], [tGrassA, tGrassB], [tGrassB, tGrassC]], [1, 1]),
paintClass(clDirt)
],
avoidClasses(clWater, 1, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 4, clSea, 0),
scaleByMapSize(15, 45)
);
}
scaleByMapSize(15, 45));
RMS.SetProgress(75);
log("Creating grass patches...");
var sizes = [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)];
for (var i = 0; i < sizes.length; i++)
{
placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
painter = new LayeredPainter([tGrassC, tGrassPatch], [2]);
for (let size of [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)])
createAreas(
placer,
painter,
avoidClasses(clWater, 1, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 4, clSea, 0),
scaleByMapSize(15, 45)
);
}
new ClumpPlacer(size, 0.3, 0.06, 0.5),
new LayeredPainter([tGrassC, tGrassPatch], [2]),
avoidClasses(clWater, 1, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 6, clSea, 0, clBaseResource, 6),
scaleByMapSize(15, 45));
RMS.SetProgress(80);
@ -381,19 +346,14 @@ createObjectGroupsDeprecated(group, 0,
);
log("Creating straggler trees...");
var types = [oPoplar, oPalm, oApple]; // some variation
var types = [oPoplar, oPalm, oApple];
var num = floor(numStragglers / types.length);
for (var i = 0; i < types.length; ++i)
{
group = new SimpleGroup(
[new SimpleObject(types[i], 1,1, 0,3)],
true, clForest
);
createObjectGroupsDeprecated(group, 0,
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
);
}
num);
log("Creating small grass tufts...");
group = new SimpleGroup(

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

@ -63,28 +63,25 @@ InitMap();
const numPlayers = getNumPlayers();
const mapSize = getMapSize();
let clPlayer = createTileClass();
let clHill = createTileClass();
let clForest = createTileClass();
let clDirt = createTileClass();
let clRock = createTileClass();
let clMetal = createTileClass();
let clFood = createTileClass();
let clBaseResource = createTileClass();
let clLand = createTileClass();
const clPlayer = createTileClass();
const clHill = createTileClass();
const clForest = createTileClass();
const clDirt = createTileClass();
const clRock = createTileClass();
const clMetal = createTileClass();
const clFood = createTileClass();
const clBaseResource = createTileClass();
const clLand = createTileClass();
const shoreRadius = 6;
const landHeight = 3;
initTerrain(tWater);
// some constants
let radius = scaleByMapSize(15, 25);
let fx = fractionToTiles(0.5);
let fz = fractionToTiles(0.5);
let startAngle = randFloat(0, TWO_PI);
var startAngle = randFloat(0, 2 * Math.PI);
// Group players by team
let teams = [];
var teams = [];
for (let i = 0; i < numPlayers; ++i)
{
let team = getPlayerTeam(i);
@ -113,14 +110,9 @@ for (let i = 0; i < numPlayers; ++i)
}
// Get number of used team IDs
let numTeams = teams.filter(team => team).length;
RMS.SetProgress(10);
let shoreRadius = 6;
let elevation = 3;
let teamNo = 0;
var numTeams = teams.filter(team => team).length;
var teamNo = 0;
for (let i = 0; i < teams.length; ++i)
{
if (!teams[i])
@ -140,18 +132,14 @@ for (let i = 0; i < teams.length; ++i)
addCivicCenterAreaToClass(ix, iz, clPlayer);
// create an island
let placer = new ChainPlacer(2, floor(scaleByMapSize(5, 11)), floor(scaleByMapSize(60, 250)), 1, ix, iz, 0, [floor(mapSize * 0.01)]);
let terrainPainter = new LayeredPainter(
[tMainTerrain, tMainTerrain, tMainTerrain], // terrains
[1, shoreRadius] // widths
);
let elevationPainter = new SmoothElevationPainter(
ELEVATION_SET, // type
elevation, // elevation
shoreRadius // blend radius
);
createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], null);
createArea(
new ChainPlacer(2, Math.floor(scaleByMapSize(5, 11)), Math.floor(scaleByMapSize(60, 250)), 1, ix, iz, 0, [Math.floor(mapSize * 0.01)]),
[
new LayeredPainter([tMainTerrain, tMainTerrain, tMainTerrain], [1, shoreRadius]),
new SmoothElevationPainter(ELEVATION_SET, landHeight, shoreRadius),
paintClass(clLand)
],
null);
placeCivDefaultEntities(fx, fz, teams[i][p], { "iberWall": false });
}
@ -235,9 +223,9 @@ for (let i = 0; i < teams.length; ++i)
RMS.SetProgress(40);
log("Creating expansion islands...");
let landAreas = [];
let playerConstraint = new AvoidTileClassConstraint(clPlayer, floor(scaleByMapSize(12, 16)));
let landConstraint = new AvoidTileClassConstraint(clLand, floor(scaleByMapSize(12, 16)));
var landAreas = [];
var playerConstraint = new AvoidTileClassConstraint(clPlayer, Math.floor(scaleByMapSize(12, 16)));
var landConstraint = new AvoidTileClassConstraint(clLand, Math.floor(scaleByMapSize(12, 16)));
for (let x = 0; x < mapSize; ++x)
for (let z = 0; z < mapSize; ++z)
@ -245,28 +233,22 @@ for (let x = 0; x < mapSize; ++x)
landAreas.push([x, z]);
log("Creating big islands...");
let chosenPoint;
let landAreaLen;
let numIslands = scaleByMapSize(4, 14);
for (let i = 0; i < numIslands; ++i)
{
landAreaLen = landAreas.length;
let landAreaLen = landAreas.length;
if (!landAreaLen)
break;
chosenPoint = pickRandom(landAreas);
let chosenPoint = pickRandom(landAreas);
// create big islands
let placer = new ChainPlacer(floor(scaleByMapSize(4, 8)), floor(scaleByMapSize(8, 14)), floor(scaleByMapSize(25, 60)), 0.07, chosenPoint[0], chosenPoint[1], scaleByMapSize(30, 70));
let terrainPainter = new LayeredPainter(
[tMainTerrain, tMainTerrain], // terrains
[2] // widths
);
let elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 6);
let newIsland = createAreas(
placer,
[terrainPainter, elevationPainter, paintClass(clLand)],
new ChainPlacer(Math.floor(scaleByMapSize(4, 8)), Math.floor(scaleByMapSize(8, 14)), Math.floor(scaleByMapSize(25, 60)), 0.07, chosenPoint[0], chosenPoint[1], scaleByMapSize(30, 70)),
[
new LayeredPainter([tMainTerrain, tMainTerrain], [2]),
new SmoothElevationPainter(ELEVATION_SET, landHeight, 6),
paintClass(clLand)
],
avoidClasses(clLand, 3, clPlayer, 3),
1, 1
);
@ -293,25 +275,21 @@ log("Creating small islands...");
numIslands = scaleByMapSize(6, 18) * scaleByMapSize(1, 3);
for (let i = 0; i < numIslands; ++i)
{
landAreaLen = landAreas.length;
let landAreaLen = landAreas.length;
if (!landAreaLen)
break;
chosenPoint = pickRandom(landAreas);
let placer = new ChainPlacer(floor(scaleByMapSize(4, 7)), floor(scaleByMapSize(7, 10)), floor(scaleByMapSize(16, 40)), 0.07, chosenPoint[0], chosenPoint[1], scaleByMapSize(22, 40));
let terrainPainter = new LayeredPainter(
[tMainTerrain, tMainTerrain], // terrains
[2] // widths
);
let elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 6);
let chosenPoint = pickRandom(landAreas);
let newIsland = createAreas(
placer,
[terrainPainter, elevationPainter, paintClass(clLand)],
new ChainPlacer(Math.floor(scaleByMapSize(4, 7)), Math.floor(scaleByMapSize(7, 10)), Math.floor(scaleByMapSize(16, 40)), 0.07, chosenPoint[0], chosenPoint[1], scaleByMapSize(22, 40)),
[
new LayeredPainter([tMainTerrain, tMainTerrain], [2]),
new SmoothElevationPainter(ELEVATION_SET, landHeight, 6),
paintClass(clLand)
],
avoidClasses(clLand, 3, clPlayer, 3),
1, 1
);
1,
1);
if (newIsland === undefined)
continue;
@ -366,18 +344,17 @@ createForests(
...rBiomeTreeCount(1));
log("Creating hills...");
let placer = new ChainPlacer(1, floor(scaleByMapSize(4, 6)), floor(scaleByMapSize(16, 40)), 0.5);
let painter = new LayeredPainter(
[tCliff, tHill], // terrains
[2] // widths
);
let elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 18, 2);
createAreas(
placer,
[painter, elevationPainter, paintClass(clHill)],
new ChainPlacer(1, Math.floor(scaleByMapSize(4, 6)), Math.floor(scaleByMapSize(16, 40)), 0.5),
[
new LayeredPainter([tCliff, tHill], [2]),
new SmoothElevationPainter(ELEVATION_SET, 18, 2),
paintClass(clHill)
],
[avoidClasses(clBaseResource, 20, clHill, 15, clRock, 6, clMetal, 6), stayClasses(clLand, 0)],
scaleByMapSize(4, 13)
);
for (let i = 0; i < 3; ++i)
globalSmoothHeightmap();
@ -419,37 +396,24 @@ if (currentBiome() == "desert")
}
log("Creating dirt patches...");
let sizes = [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)];
let numb = currentBiome() == "savanna" ? 3 : 1;
for (let i = 0; i < sizes.length; ++i)
{
placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
painter = new LayeredPainter(
[[tMainTerrain,tTier1Terrain], [tTier1Terrain,tTier2Terrain], [tTier2Terrain,tTier3Terrain]], // terrains
[1, 1] // widths
);
for (let size of [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)])
createAreas(
placer,
[painter, paintClass(clDirt)],
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
[
new LayeredPainter([[tMainTerrain, tTier1Terrain], [tTier1Terrain, tTier2Terrain], [tTier2Terrain, tTier3Terrain]], [1, 1]),
paintClass(clDirt)
],
[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 0), stayClasses(clLand, 4)],
numb*scaleByMapSize(15, 45)
);
}
numb*scaleByMapSize(15, 45));
log("Creating grass patches...");
sizes = [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)];
for (let i = 0; i < sizes.length; ++i)
{
placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
painter = new TerrainPainter(tTier4Terrain);
for (let size of [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)])
createAreas(
placer,
painter,
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
new TerrainPainter(tTier4Terrain),
[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 0), stayClasses(clLand, 4)],
numb * scaleByMapSize(15, 45)
);
}
numb * scaleByMapSize(15, 45));
log("Creating small decorative rocks...");
let group = new SimpleGroup(
@ -513,8 +477,6 @@ createObjectGroupsDeprecated(group, 0,
scaleByMapSize(10, 20), 100
);
placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius, [stayClasses(clLand, 5)]);
log("Creating small grass tufts...");
let planetm = currentBiome() == "tropic" ? 8 : 1;
group = new SimpleGroup(

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

@ -172,8 +172,7 @@ var chosenPoint;
var landAreaLen;
log("Creating big islands...");
var numIslands = scaleByMapSize(4, 14);
for (var i = 0; i < numIslands; ++i)
for (let i = 0; i < scaleByMapSize(4, 14); ++i)
{
landAreaLen = landAreas.length;
if (!landAreaLen)
@ -181,26 +180,30 @@ for (var i = 0; i < numIslands; ++i)
chosenPoint = pickRandom(landAreas);
// create big islands
placer = new ChainPlacer(floor(scaleByMapSize(4, 8)), floor(scaleByMapSize(8, 14)), floor(scaleByMapSize(25, 60)), 0.07, chosenPoint[0], chosenPoint[1], scaleByMapSize(30,70));
//placer = new ClumpPlacer(floor(hillSize*randFloat(0.9,2.1)), 0.80, 0.1, 0.07, chosenPoint[0], chosenPoint[1]);
terrainPainter = new LayeredPainter(
[tMainTerrain, tMainTerrain], // terrains
[2] // widths
);
elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 6);
var newIsland = createAreas(
placer,
[terrainPainter, elevationPainter, paintClass(clLand)],
new ChainPlacer(
Math.floor(scaleByMapSize(4, 8)),
Math.floor(scaleByMapSize(8, 14)),
Math.floor(scaleByMapSize(25, 60)),
0.07,
chosenPoint[0],
chosenPoint[1],
scaleByMapSize(30, 70)),
[
new LayeredPainter([tMainTerrain, tMainTerrain], [2]),
new SmoothElevationPainter(ELEVATION_SET, 3, 6),
paintClass(clLand)
],
avoidClasses(clLand, 3, clPlayer, 3),
1, 1
);
1,
1);
if (newIsland && newIsland.length)
{
var n = 0;
for (var j = 0; j < landAreaLen; ++j)
for (var j = 0; j < landAreas.length; ++j)
{
var x = landAreas[j][0], z = landAreas[j][1];
let [x, z] = landAreas[j];
if (playerConstraint.allows(x, z) && landConstraint.allows(x, z))
landAreas[n++] = landAreas[j];
}
@ -212,8 +215,7 @@ playerConstraint = new AvoidTileClassConstraint(clPlayer, floor(scaleByMapSize(9
landConstraint = new AvoidTileClassConstraint(clLand, floor(scaleByMapSize(9,12)));
log("Creating small islands...");
numIslands = scaleByMapSize(6, 18) * scaleByMapSize(1,3);
for (var i = 0; i < numIslands; ++i)
for (let i = 0; i < 6 * Math.pow(scaleByMapSize(1, 3), 2); ++i)
{
landAreaLen = landAreas.length;
if (!landAreaLen)
@ -221,24 +223,30 @@ for (var i = 0; i < numIslands; ++i)
chosenPoint = pickRandom(landAreas);
placer = new ChainPlacer(floor(scaleByMapSize(4, 7)), floor(scaleByMapSize(7, 10)), floor(scaleByMapSize(16, 40)), 0.07, chosenPoint[0], chosenPoint[1], scaleByMapSize(22,40));
terrainPainter = new LayeredPainter(
[tMainTerrain, tMainTerrain], // terrains
[2] // widths
);
elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 6);
createAreas(
placer,
[terrainPainter, elevationPainter, paintClass(clLand)],
new ChainPlacer(
Math.floor(scaleByMapSize(4, 7)),
Math.floor(scaleByMapSize(7, 10)),
Math.floor(scaleByMapSize(16, 40)),
0.07,
chosenPoint[0],
chosenPoint[1],
scaleByMapSize(22, 40)),
[
new LayeredPainter([tMainTerrain, tMainTerrain], [2]),
new SmoothElevationPainter(ELEVATION_SET, 3, 6),
paintClass(clLand)
],
avoidClasses(clLand, 3, clPlayer, 3),
1, 1
);
1,
1);
if (newIsland !== undefined)
{
var temp = [];
for (var j = 0; j < landAreaLen; ++j)
{
var x = landAreas[j][0], z = landAreas[j][1];
let [x, z] = landAreas[j];
if (playerConstraint.allows(x, z) && landConstraint.allows(x, z))
temp.push([x, z]);
}
@ -262,28 +270,22 @@ for (var i = 0; i < numPlayers; i++)
}
log("Creating bumps...");
placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1);
painter = new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2);
createAreas(
placer,
painter,
new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1),
new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2),
[avoidClasses(clPlayer, 0), stayClasses(clLand, 3)],
scaleByMapSize(20, 100)
);
scaleByMapSize(20, 100));
log("Creating hills...");
placer = new ChainPlacer(1, floor(scaleByMapSize(4, 6)), floor(scaleByMapSize(16, 40)), 0.5);
terrainPainter = new LayeredPainter(
[tCliff, tHill], // terrains
[2] // widths
);
elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 18, 2);
createAreas(
placer,
[terrainPainter, elevationPainter, paintClass(clHill)],
new ChainPlacer(1, Math.floor(scaleByMapSize(4, 6)), Math.floor(scaleByMapSize(16, 40)), 0.5),
[
new LayeredPainter([tCliff, tHill], [2]),
new SmoothElevationPainter(ELEVATION_SET, 18, 2),
paintClass(clHill)
],
[avoidClasses(clPlayer, 2, clHill, 15), stayClasses(clLand, 0)],
scaleByMapSize(4, 13)
);
scaleByMapSize(4, 13));
// calculate desired number of trees for map (based on size)
if (currentBiome() == "savanna")
@ -312,66 +314,48 @@ log("Creating forests...");
var types = [
[[tForestFloor2, tMainTerrain, pForest1], [tForestFloor2, pForest1]],
[[tForestFloor1, tMainTerrain, pForest2], [tForestFloor1, pForest2]]
]; // some variation
];
if (currentBiome() != "savanna")
{
var size = numForest / (scaleByMapSize(3,6) * numPlayers);
var num = floor(size / types.length);
for (var i = 0; i < types.length; ++i)
{
placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), numForest / (num * floor(scaleByMapSize(2,5))), 0.5);
painter = new LayeredPainter(
types[i], // terrains
[2] // widths
);
for (let type of types)
createAreas(
placer,
[painter, paintClass(clForest)],
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), numForest / (num * Math.floor(scaleByMapSize(2, 5))), 0.5),
[
new LayeredPainter(type, [2]),
paintClass(clForest)
],
[avoidClasses(clPlayer, 0, clForest, 10, clHill, 0), stayClasses(clLand, 6)],
num
);
}
num);
}
RMS.SetProgress(50);
log("Creating dirt patches...");
var sizes = [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)];
var numb = 1;
if (currentBiome() == "savanna")
numb = 3;
for (var i = 0; i < sizes.length; i++)
{
placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
painter = new LayeredPainter(
[[tMainTerrain,tTier1Terrain],[tTier1Terrain,tTier2Terrain], [tTier2Terrain,tTier3Terrain]], // terrains
[1,1] // widths
);
var numberOfPatches = scaleByMapSize(15, 45) * (currentBiome() == "savanna" ? 3 : 1);
for (let size of [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)])
createAreas(
placer,
[painter, paintClass(clDirt)],
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
[
new LayeredPainter([[tMainTerrain, tTier1Terrain], [tTier1Terrain, tTier2Terrain], [tTier2Terrain, tTier3Terrain]], [1, 1]),
paintClass(clDirt)
],
[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 0), stayClasses(clLand, 6)],
numb*scaleByMapSize(15, 45)
);
}
numberOfPatches);
log("Creating grass patches...");
var sizes = [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)];
for (var i = 0; i < sizes.length; i++)
{
placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
painter = new TerrainPainter(tTier4Terrain);
for (let size of [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)])
createAreas(
placer,
painter,
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
new TerrainPainter(tTier4Terrain),
[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 0), stayClasses(clLand, 6)],
numb*scaleByMapSize(15, 45)
);
}
numberOfPatches);
RMS.SetProgress(55);
log("Creating stone mines...");
group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
var group = new SimpleGroup([new SimpleObject(oStoneSmall, 0, 2, 0, 4), new SimpleObject(oStoneLarge, 1, 1, 0, 4)], true, clRock);
createObjectGroupsDeprecated(group, 0,
[avoidClasses(clForest, 1, clPlayer, 0, clRock, 10, clHill, 1), stayClasses(clLand, 5)],
scaleByMapSize(4,16), 100
@ -462,19 +446,14 @@ createObjectGroupsDeprecated(group, 0,
RMS.SetProgress(85);
log("Creating straggler trees...");
var types = [oTree1, oTree2, oTree4, oTree3]; // some variation
var types = [oTree1, oTree2, oTree4, oTree3];
var num = floor(numStragglers / types.length);
for (var i = 0; i < types.length; ++i)
{
group = new SimpleGroup(
[new SimpleObject(types[i], 1,1, 0,3)],
true, clForest
);
createObjectGroupsDeprecated(group, 0,
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
);
}
num);
var planetm = 1;
if (currentBiome() == "tropic")

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

@ -156,27 +156,21 @@ paintRiver({
});
log("Creating shores...");
for (var i = 0; i < scaleByMapSize(20,120); i++)
{
placer = new ChainPlacer(
1,
Math.floor(scaleByMapSize(4, 6)),
Math.floor(scaleByMapSize(16, 30)),
1,
randIntExclusive(0.28 * mapSize, 0.34 * mapSize),
randIntExclusive(0.1 * mapSize, 0.9 * mapSize));
var terrainPainter = new LayeredPainter(
[tGrass, tGrass], // terrains
[2] // widths
);
var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 3);
for (let i = 0; i < scaleByMapSize(20, 120); ++i)
createArea(
placer,
[terrainPainter, elevationPainter, unPaintClass(clWater)],
null
);
}
new ChainPlacer(
1,
Math.floor(scaleByMapSize(4, 6)),
Math.floor(scaleByMapSize(16, 30)),
1,
randIntExclusive(0.28 * mapSize, 0.34 * mapSize),
randIntExclusive(0.1 * mapSize, 0.9 * mapSize)),
[
new LayeredPainter([tGrass, tGrass], [2]),
new SmoothElevationPainter(ELEVATION_SET, 3, 3),
unPaintClass(clWater)
],
null);
paintTerrainBasedOnHeight(-6, 1, 1, tWater);
paintTerrainBasedOnHeight(1, 2.8, 1, tShoreBlend);
@ -186,21 +180,17 @@ paintTileClassBasedOnHeight(-6, 0.5, 1, clWater);
RMS.SetProgress(45);
log("Creating hills...");
placer = new ChainPlacer(1, floor(scaleByMapSize(4, 6)), floor(scaleByMapSize(16, 40)), 0.1);
var terrainPainter = new LayeredPainter(
[tCliff, tGrass], // terrains
[3] // widths
);
var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 25, 3);
createAreas(
placer,
[terrainPainter, elevationPainter, paintClass(clHill)],
new ChainPlacer(1, Math.floor(scaleByMapSize(4, 6)), Math.floor(scaleByMapSize(16, 40)), 0.1),
[
new LayeredPainter([tCliff, tGrass], [3]),
new SmoothElevationPainter(ELEVATION_SET, 25, 3),
paintClass(clHill)
],
[avoidClasses(clPlayer, 20, clHill, 5, clWater, 2, clBaseResource, 2), stayClasses(clMountains, 0)],
scaleByMapSize(5, 40) * numPlayers
);
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;
@ -213,62 +203,48 @@ log("Creating forests...");
var types = [
[[tGrass, tGrass, tGrass, tGrass, pForestD], [tGrass, tGrass, tGrass, pForestD]],
[[tGrass, tGrass, tGrass, tGrass, pForestP], [tGrass, tGrass, tGrass, pForestP]]
]; // some variation
];
var size = numForest / (scaleByMapSize(3,6) * numPlayers);
var num = floor(size / types.length);
for (var i = 0; i < types.length; ++i)
{
placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), numForest / (num * floor(scaleByMapSize(2,4))), 0.5);
painter = new LayeredPainter(
types[i], // terrains
[2] // widths
);
for (let type of types)
createAreas(
placer,
[painter, paintClass(clForest)],
new ChainPlacer(
1,
Math.floor(scaleByMapSize(3, 5)),
numForest / (num * Math.floor(scaleByMapSize(2, 4))),
0.5),
[
new LayeredPainter(type, [2]),
paintClass(clForest)
],
avoidClasses(clPlayer, 20, clForest, 10, clHill, 0, clWater, 8),
num
);
}
num);
RMS.SetProgress(70);
log("Creating grass patches...");
var sizes = [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)];
for (var i = 0; i < sizes.length; i++)
{
placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
painter = new LayeredPainter(
[tGrassC,tGrassA,tGrassB], // terrains
[2,1] // widths
);
for (let size of [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)])
createAreas(
placer,
[painter, paintClass(clDirt)],
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
[
new LayeredPainter([tGrassC, tGrassA, tGrassB], [2, 1]),
paintClass(clDirt)
],
avoidClasses(clWater, 8, clForest, 0, clHill, 0, clPlayer, 12, clDirt, 16),
scaleByMapSize(20, 80)
);
}
var sizes = [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)];
for (var i = 0; i < sizes.length; i++)
{
placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
painter = new LayeredPainter(
[tPlants,tPlants], // terrains
[1] // widths
);
scaleByMapSize(20, 80));
for (let size of [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)])
createAreas(
placer,
[painter, paintClass(clDirt)],
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
[
new LayeredPainter([tPlants, tPlants], [1]),
paintClass(clDirt)
],
avoidClasses(clWater, 8, clForest, 0, clHill, 0, clPlayer, 12, clDirt, 16),
scaleByMapSize(20, 80)
);
}
scaleByMapSize(20, 80));
log("Creating stone mines...");
group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
var group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
createObjectGroupsDeprecated(group, 0,
avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clRock, 10, clHill, 1),
scaleByMapSize(4,16), 100
@ -344,19 +320,14 @@ createObjectGroupsDeprecated(group, 0,
RMS.SetProgress(95);
log("Creating straggler trees...");
var types = [oTree, oPalm]; // some variation
var types = [oTree, oPalm];
var num = floor(numStragglers / types.length);
for (var i = 0; i < types.length; ++i)
{
group = new SimpleGroup(
[new SimpleObject(types[i], 1,1, 0,3)],
true, clForest
);
createObjectGroupsDeprecated(group, 0,
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
);
}
num);
log("Creating deer...");
group = new SimpleGroup(

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

@ -131,40 +131,33 @@ for (var i = 0; i < numPlayers; i++)
RMS.SetProgress(20);
//create the lake
var fx = fractionToTiles(0.5);
var fz = fractionToTiles(0.5);
ix = round(fx);
iz = round(fz);
const lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 6))));
var placer = new ChainPlacer(2, floor(scaleByMapSize(5, 16)), floor(scaleByMapSize(35, 200)), 1, ix, iz, 0, [floor(mapSize * 0.17 * lSize)]);
var terrainPainter = new LayeredPainter(
[tShore, tWater, tWater, tWater], // terrains
[1, 4, 2] // widths
);
var elevationPainter = new SmoothElevationPainter(
ELEVATION_SET, // type
-3, // elevation
4 // blend radius
);
createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 20));
log("Creating the lake...")
createArea(
new ChainPlacer(
2,
Math.floor(scaleByMapSize(5, 16)),
Math.floor(scaleByMapSize(35, 200)),
1,
Math.round(fractionToTiles(0.5)),
Math.round(fractionToTiles(0.5)),
0,
[Math.floor(mapSize * 0.17 * Math.pow(scaleByMapSize(1, 6), 1/8))]),
[
new SmoothElevationPainter(ELEVATION_SET, -3, 4),
paintClass(clWater)
],
avoidClasses(clPlayer, 20));
log("Creating more shore jaggedness...");
placer = new ChainPlacer(2, floor(scaleByMapSize(4, 6)), 3, 1);
terrainPainter = new LayeredPainter(
[tCliff, tHill], // terrains
[2] // widths
);
elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 4);
createAreas(
placer,
[terrainPainter, elevationPainter, unPaintClass(clWater)],
new ChainPlacer(2, Math.floor(scaleByMapSize(4, 6)), 3, 1),
[
new LayeredPainter([tCliff, tHill], [2]),
unPaintClass(clWater)
],
borderClasses(clWater, 4, 7),
scaleByMapSize(12, 130) * 2, 150
);
scaleByMapSize(12, 130) * 2,
150);
paintTerrainBasedOnHeight(2.4, 3.4, 3, tMainTerrain);
paintTerrainBasedOnHeight(1, 2.4, 0, tShore);
@ -300,8 +293,10 @@ createFood
RMS.SetProgress(85);
var types = [oTree1, oTree2, oTree4, oTree3]; // some variation
createStragglerTrees(types, avoidClasses(clWater, 5, clForest, 7, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6));
createStragglerTrees(
[oTree1, oTree2, oTree4, oTree3],
avoidClasses(clWater, 5, clForest, 7, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6));
setWaterWaviness(4.0);
setWaterType("lake");

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

@ -52,6 +52,7 @@ var clShallow = createTileClass();
var playerIDs = primeSortAllPlayers();
var playerPos = placePlayersRiver();
var waterHeight = -4;
var playerX = [];
var playerZ = [];
@ -142,73 +143,105 @@ for (var i = 0; i < numPlayers; i++)
createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
}
log("Creating the main river");
var tang = randFloat(0, TWO_PI);
var placer = new PathPlacer(1, fractionToTiles(0.5), fractionToTiles(0.99), fractionToTiles(0.5), scaleByMapSize(10,20), 0.5, 3*(scaleByMapSize(1,4)), 0.1, 0.01);
var terrainPainter = new LayeredPainter(
[tShore, tWater, tWater], // terrains
[1, 3] // widths
);
var elevationPainter = new SmoothElevationPainter(
ELEVATION_SET, // type
-4, // elevation
4 // blend radius
);
createArea(placer, [terrainPainter, elevationPainter], avoidClasses(clPlayer, 4));
log("Creating the main river...");
var river1 = [1, fractionToTiles(0.5)];
var river2 = [fractionToTiles(0.99), fractionToTiles(0.5)];
createArea(
new PathPlacer(...river1, ...river2, scaleByMapSize(10, 20), 0.5, 3 * scaleByMapSize(1, 4), 0.1, 0.01),
new SmoothElevationPainter(ELEVATION_SET, waterHeight, 4),
avoidClasses(clPlayer, 4));
placer = new ClumpPlacer(floor(PI*scaleByMapSize(10,20)*scaleByMapSize(10,20)/4), 0.95, 0.6, 10, 1, fractionToTiles(0.5));
var painter = new LayeredPainter([tWater, tWater], [1]);
var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -4, 2);
createArea(placer, [painter, elevationPainter], avoidClasses(clPlayer, 8));
placer = new ClumpPlacer(floor(PI*scaleByMapSize(10,20)*scaleByMapSize(10,20)/4), 0.95, 0.6, 10, fractionToTiles(0.99), fractionToTiles(0.5));
var painter = new LayeredPainter([tWater, tWater], [1]);
var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -4, 2);
createArea(placer, [painter, elevationPainter], avoidClasses(clPlayer, 8));
log("Creating the shallows of the main river");
log("Creating small puddles at the map border to ensure players being separated...");
for (let [fx, fz] of [river1, river2])
createArea(
new ClumpPlacer(Math.floor(Math.PI * Math.pow(scaleByMapSize(5, 10), 2)), 0.95, 0.6, 10, fx, fz),
new SmoothElevationPainter(ELEVATION_SET, waterHeight, 2),
avoidClasses(clPlayer, 8));
log("Creating the shallows of the main river...");
for (let i = 0; i <= randIntInclusive(3, scaleByMapSize(4, 6)); ++i)
{
var cLocation = randFloat(0.15,0.85);
passageMaker(floor(fractionToTiles(cLocation)), floor(fractionToTiles(0.35)), floor(fractionToTiles(cLocation)), floor(fractionToTiles(0.65)), scaleByMapSize(4,8), -2, -2, 2, clShallow, undefined, -4);
let cLocation = Math.floor(fractionToTiles(randFloat(0.15, 0.85)));
passageMaker(
cLocation,
Math.floor(fractionToTiles(0.35)),
cLocation,
Math.floor(fractionToTiles(0.65)),
scaleByMapSize(4, 8),
-2,
-2,
2,
clShallow,
undefined,
waterHeight);
}
log("Creating tributaries");
log("Creating tributaries...");
var riverWidth = scaleByMapSize(10, 20);
for (let i = 0; i <= randIntInclusive(8, scaleByMapSize(12, 20)); ++i)
{
log("Determining tributary destination...");
let cLocation = randFloat(0.05, 0.95);
let sign = randBool() ? 1 : -1;
let tang = sign * PI * randFloat(0.2, 0.8);
let cDistance = sign * 0.05;
var point = getTIPIADBON([fractionToTiles(cLocation), fractionToTiles(0.5 + cDistance)], [fractionToTiles(cLocation), fractionToTiles(0.5 - cDistance)], [-6, -1.5], 0.5, 5, 0.01);
if (point !== undefined)
{
var placer = new PathPlacer(floor(point[0]), floor(point[1]), floor(fractionToTiles(0.5 + 0.49*cos(tang))), floor(fractionToTiles(0.5 + 0.49*sin(tang))), scaleByMapSize(10,20), 0.4, 3*(scaleByMapSize(1,4)), 0.1, 0.05);
var terrainPainter = new LayeredPainter(
[tShore, tWater, tWater], // terrains
[1, 3] // widths
);
var elevationPainter = new SmoothElevationPainter(
ELEVATION_SET, // type
-4, // elevation
4 // blend radius
);
var success = createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 3, clWater, 3, clShallow, 2));
if (success !== undefined)
{
placer = new ClumpPlacer(floor(PI*scaleByMapSize(10,20)*scaleByMapSize(10,20)/4), 0.95, 0.6, 10, fractionToTiles(0.5 + 0.49*cos(tang)), fractionToTiles(0.5 + 0.49*sin(tang)));
var painter = new LayeredPainter([tWater, tWater], [1]);
var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -4, 2);
createArea(placer, [painter, elevationPainter], avoidClasses(clPlayer, 3));
}
}
let point = getTIPIADBON(
[fractionToTiles(cLocation), fractionToTiles(0.5 + cDistance)],
[fractionToTiles(cLocation), fractionToTiles(0.5 - cDistance)],
[-6, -1.5],
0.5,
5,
0.01);
if (point === undefined)
continue;
let fx = fractionToTiles(0.5 + 0.49 * Math.cos(tang));
let fz = fractionToTiles(0.5 + 0.49 * Math.sin(tang));
log("Creating tributary river...");
let success = createArea(
new PathPlacer(
Math.floor(point[0]),
Math.floor(point[1]),
Math.floor(fx),
Math.floor(fz),
riverWidth,
0.4,
3 * scaleByMapSize(1, 4),
0.1,
0.05),
[
new SmoothElevationPainter(ELEVATION_SET, waterHeight, 4),
paintClass(clWater)
],
avoidClasses(clPlayer, 3, clWater, 3, clShallow, 2));
if (success === undefined)
continue;
log("Creating small puddles at the map border to ensure players being separated...");
createArea(
new ClumpPlacer(Math.floor(Math.PI * Math.pow(riverWidth, 2) / 4), 0.95, 0.6, 10, fx, fz),
new SmoothElevationPainter(ELEVATION_SET, waterHeight, 2),
avoidClasses(clPlayer, 3));
}
passageMaker(floor(fractionToTiles(0.2)), floor(fractionToTiles(0.25)), floor(fractionToTiles(0.8)), floor(fractionToTiles(0.25)), scaleByMapSize(4,8), -2, -2, 2, clShallow, undefined, -4);
passageMaker(floor(fractionToTiles(0.2)), floor(fractionToTiles(0.75)), floor(fractionToTiles(0.8)), floor(fractionToTiles(0.75)), scaleByMapSize(4,8), -2, -2, 2, clShallow, undefined, -4);
log("Creating shallows to make tributaries passable...");
for (let coord of [0.25, 0.75])
passageMaker(
Math.floor(fractionToTiles(0.2)),
Math.floor(fractionToTiles(coord)),
Math.floor(fractionToTiles(0.8)),
Math.floor(fractionToTiles(coord)),
scaleByMapSize(4, 8),
-2,
-2,
2,
clShallow,
undefined,
waterHeight);
paintTerrainBasedOnHeight(-5, 1, 1, tWater);
paintTerrainBasedOnHeight(1, 2, 1, pForestR);
@ -217,15 +250,12 @@ paintTileClassBasedOnHeight(-6, 0.5, 1, clWater);
RMS.SetProgress(50);
log("Creating bumps...");
placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1);
painter = new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2);
createAreas(
placer,
painter,
new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1),
new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2),
avoidClasses(clWater, 2, clPlayer, 15),
scaleByMapSize(100, 200)
);
RMS.SetProgress(55);
// calculate desired number of trees for map (based on size)
@ -241,64 +271,48 @@ log("Creating forests...");
var types = [
[[tGrassDForest, tGrass, pForestB], [tGrassDForest, pForestB]],
[[tGrassPForest, tGrass, pForestO], [tGrassPForest, pForestO]]
]; // some variation
var size = numForest / (scaleByMapSize(3,6) * numPlayers);
var num = floor(size / types.length);
for (var i = 0; i < types.length; ++i)
{
placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), numForest / num, 0.5);
painter = new LayeredPainter(
types[i], // terrains
[2] // widths
);
];
var size = numForest / (scaleByMapSize(3, 6) * numPlayers);
var num = Math.floor(size / types.length);
for (let type of types)
createAreas(
placer,
[painter, paintClass(clForest)],
avoidClasses(clPlayer, 15, clWater, 3, clForest, 16, clHill, 1),
num
);
}
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);
RMS.SetProgress(70);
log("Creating dirt patches...");
var sizes = [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)];
for (var i = 0; i < sizes.length; i++)
{
placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
painter = new LayeredPainter(
[[tGrass,tGrassA], tGrassB, [tGrassB,tGrassC]], // terrains
[1,1] // widths
);
for (let size of [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)])
createAreas(
placer,
[painter, paintClass(clDirt)],
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
[
new LayeredPainter([[tGrass,tGrassA], tGrassB, [tGrassB,tGrassC]], [1, 1]),
paintClass(clDirt)
],
avoidClasses(clWater, 1, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 6),
scaleByMapSize(15, 45)
);
}
log("Creating grass patches...");
var sizes = [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)];
for (var i = 0; i < sizes.length; i++)
{
placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
painter = new LayeredPainter(
[tGrassPatchBlend, tGrassPatch], // terrains
[1] // widths
);
for (let size of [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)])
createAreas(
placer,
painter,
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
new LayeredPainter([tGrassPatchBlend, tGrassPatch], [1]),
avoidClasses(clWater, 1, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 6),
scaleByMapSize(15, 45)
);
}
RMS.SetProgress(80);
log("Creating stone mines...");
group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
var group = new SimpleGroup([new SimpleObject(oStoneSmall, 0, 2, 0, 4), new SimpleObject(oStoneLarge, 1, 1, 0, 4)], true, clRock);
createObjectGroupsDeprecated(group, 0,
[avoidClasses(clWater, 0, clForest, 1, clPlayer, 15, clRock, 10, clHill, 1)],
scaleByMapSize(4,16), 100
@ -373,19 +387,14 @@ createObjectGroupsDeprecated(group, 0,
);
log("Creating straggler trees...");
var types = [oOak, oBeech]; // some variation
var types = [oOak, oBeech];
var num = floor(numStragglers / types.length);
for (var i = 0; i < types.length; ++i)
{
group = new SimpleGroup(
[new SimpleObject(types[i], 1,1, 0,3)],
true, clForest
);
createObjectGroupsDeprecated(group, 0,
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
);
}
num);
log("Creating small grass tufts...");
group = new SimpleGroup(

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

@ -233,7 +233,6 @@ createFood
RMS.SetProgress(85);
var types = [oTree1, oTree2, oTree4, oTree3]; // some variation
createStragglerTrees(types);
createStragglerTrees([oTree1, oTree2, oTree4, oTree3]);
ExportMap();

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

@ -57,6 +57,8 @@ var clFood = createTileClass();
var clBaseResource = createTileClass();
var clLand = createTileClass();
var landHeight = 3;
var playerIDs = sortAllPlayers();
// place players
@ -170,71 +172,69 @@ for (var i = 0; i < numPlayers; i++)
placeDefaultDecoratives(fx, fz, aGrassShort, clBaseResource, radius);
//create docks
var dockLocation = getTIPIADBON([ix, iz], [mapSize / 2, mapSize / 2], [-3 , 2.6], 0.5, 3);
if (dockLocation !== undefined)
placeObject(dockLocation[0], dockLocation[1], "structures/" + getCivCode(id-1) + "_dock", id, playerAngle[i] + PI);
let dockLocation = getTIPIADBON([ix, iz], [mapSize / 2, mapSize / 2], [-3 , 2.6], 0.5, 3);
if (dockLocation === undefined)
{
warn("Could not place dock for player " + playerIDs[i])
continue;
}
placeObject(
dockLocation[0],
dockLocation[1],
"structures/" + getCivCode(playerIDs[i] - 1) + "_dock",
playerIDs[i] - 1,
playerAngle[i] + Math.PI);
}
RMS.SetProgress(15);
//Create the continent body
var fx = fractionToTiles(0.12);
var fz = fractionToTiles(0.5);
var ix = round(fx);
var iz = round(fz);
var placer = new ClumpPlacer(mapArea * 0.50, 0.80, 0.08, 10, ix, iz);
var terrainPainter = new LayeredPainter(
[tWater, tShore, tMainTerrain], // terrains
[4, 2] // widths
);
var elevationPainter = new SmoothElevationPainter(
ELEVATION_SET, // type
3, // elevation
4 // blend radius
);
createArea(placer, [terrainPainter, elevationPainter, paintClass(clLand)], avoidClasses(clPlayer, 8));
log("Create the continent body...");
createArea(
new ClumpPlacer(mapArea * 0.50, 0.8, 0.08, 10, Math.round(fractionToTiles(0.12)), Math.round(fractionToTiles(0.5))),
[
new LayeredPainter([tWater, tShore, tMainTerrain], [4, 2]),
new SmoothElevationPainter(ELEVATION_SET, landHeight, 4),
paintClass(clLand)
],
avoidClasses(clPlayer, 8));
RMS.SetProgress(20);
log("Creating shore jaggedness...");
placer = new ClumpPlacer(scaleByMapSize(15, 80), 0.2, 0.1, 1);
terrainPainter = new LayeredPainter(
[tMainTerrain, tMainTerrain], // terrains
[2] // widths
);
elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 4);
createAreas(
placer,
[terrainPainter, elevationPainter, paintClass(clLand)],
[borderClasses(clLand, 6, 3), avoidClasses(clPlayer, 8)],
scaleByMapSize(20, 150) * 2, 150
);
new ClumpPlacer(scaleByMapSize(15, 80), 0.2, 0.1, 1),
[
new LayeredPainter([tMainTerrain, tMainTerrain], [2]),
new SmoothElevationPainter(ELEVATION_SET, landHeight, 4),
paintClass(clLand)
],
[
borderClasses(clLand, 6, 3),
avoidClasses(clPlayer, 8)
],
scaleByMapSize(2, 15) * 20,
150);
paintTerrainBasedOnHeight(1, 3, 0, tShore);
paintTerrainBasedOnHeight(-8, 1, 2, tWater);
RMS.SetProgress(25);
log("Creating bumps...");
placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1);
painter = new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2);
createAreas(
placer,
painter,
new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1),
new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2),
[avoidClasses(clPlayer, 10), stayClasses(clLand, 3)],
scaleByMapSize(100, 200)
);
RMS.SetProgress(30);
log("Creating hills...");
placer = new ClumpPlacer(scaleByMapSize(20, 150), 0.2, 0.1, 1);
terrainPainter = new LayeredPainter(
[tCliff, tHill], // terrains
[2] // widths
);
elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 18, 2);
createAreas(
placer,
[terrainPainter, elevationPainter, paintClass(clHill)],
new ClumpPlacer(scaleByMapSize(20, 150), 0.2, 0.1, 1),
[
new LayeredPainter([tCliff, tHill], [2]),
new SmoothElevationPainter(ELEVATION_SET, 18, 2),
paintClass(clHill)
],
[avoidClasses(clPlayer, 10, clHill, 15), stayClasses(clLand, 7)],
scaleByMapSize(1, 4) * numPlayers
);
@ -268,63 +268,56 @@ log("Creating forests...");
var types = [
[[tForestFloor2, tMainTerrain, pForest1], [tForestFloor2, pForest1]],
[[tForestFloor1, tMainTerrain, pForest2], [tForestFloor1, pForest2]]
]; // some variation
];
var size = numForest / (scaleByMapSize(2,8) * numPlayers) *
(currentBiome() == "savanna" ? 2 : 1);
var num = floor(size / types.length);
for (var i = 0; i < types.length; ++i)
{
placer = new ClumpPlacer(numForest / num, 0.1, 0.1, 1);
painter = new LayeredPainter(
types[i], // terrains
[2] // widths
);
for (let type of types)
createAreas(
placer,
[painter, paintClass(clForest)],
new ClumpPlacer(numForest / num, 0.1, 0.1, 1),
[
new LayeredPainter(type, [2]),
paintClass(clForest)
],
[avoidClasses(clPlayer, 6, clForest, 10, clHill, 0), stayClasses(clLand, 7)],
num
);
}
num);
RMS.SetProgress(38);
log("Creating dirt patches...");
var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
for (var i = 0; i < sizes.length; i++)
{
placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
painter = new LayeredPainter(
[[tMainTerrain,tTier1Terrain],[tTier1Terrain,tTier2Terrain], [tTier2Terrain,tTier3Terrain]], // terrains
[1,1] // widths
);
for (let size of [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)])
createAreas(
placer,
[painter, paintClass(clDirt)],
[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 0), stayClasses(clLand, 7)],
scaleByMapSize(15, 45)
);
}
new ClumpPlacer(size, 0.3, 0.06, 0.5),
[
new LayeredPainter(
[[tMainTerrain, tTier1Terrain], [tTier1Terrain, tTier2Terrain], [tTier2Terrain, tTier3Terrain]],
[1, 1]),
paintClass(clDirt)
],
[
avoidClasses(
clForest, 0,
clHill, 0,
clDirt, 5,
clPlayer, 0),
stayClasses(clLand, 7)
],
scaleByMapSize(15, 45));
RMS.SetProgress(42);
log("Creating grass patches...");
var sizes = [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)];
for (var i = 0; i < sizes.length; i++)
{
placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
painter = new TerrainPainter(tTier4Terrain);
for (let size of [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)])
createAreas(
placer,
painter,
new ClumpPlacer(size, 0.3, 0.06, 0.5),
new TerrainPainter(tTier4Terrain),
[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 0), stayClasses(clLand, 7)],
scaleByMapSize(15, 45)
);
}
scaleByMapSize(15, 45));
RMS.SetProgress(46);
log("Creating stone mines...");
group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
var group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
createObjectGroupsDeprecated(group, 0,
[avoidClasses(clForest, 1, clPlayer, 10, clRock, 10, clHill, 1), stayClasses(clLand, 7)],
scaleByMapSize(4,16), 100
@ -414,19 +407,14 @@ createObjectGroupsDeprecated(
RMS.SetProgress(82);
log("Creating straggler trees...");
var types = [oTree1, oTree2, oTree4, oTree3]; // some variation
var types = [oTree1, oTree2, oTree4, oTree3];
var num = floor(numStragglers / types.length);
for (var i = 0; i < types.length; ++i)
{
group = new SimpleGroup(
[new SimpleObject(types[i], 1,1, 0,3)],
true, clForest
);
createObjectGroupsDeprecated(group, 0,
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
);
}
num);
RMS.SetProgress(86);
var planetm = currentBiome() == "tropic" ? 8 : 1;

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

@ -163,10 +163,15 @@ RMS.SetProgress(25);
log("Creating oasis...");
var oRadius = scaleByMapSize(14, 40);
placer = new ClumpPlacer(PI*oRadius*oRadius, 0.6, 0.15, 0, mapSize/2, mapSize/2);
painter = new LayeredPainter([[tSand, pForest], [tGrassSand25, pForestOasis], tGrassSand25, tShore, tWaterDeep], [2, 3, 1, 1]);
elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, -11, 8);
createArea(placer, [painter, elevationPainter, paintClass(clForest)], null);
createArea(
new ClumpPlacer(Math.PI * Math.pow(oRadius, 2), 0.6, 0.15, 0, mapSize/2, mapSize/2),
[
new LayeredPainter([[tSand, pForest], [tGrassSand25, pForestOasis], tGrassSand25, tShore, tWaterDeep], [2, 3, 1, 1]),
new SmoothElevationPainter(ELEVATION_MODIFY, -11, 8),
paintClass(clForest)
],
null);
RMS.SetProgress(30);
log("Creating oasis wildlife...");
@ -184,13 +189,17 @@ for (var i = 0; i < num; ++i)
++r;
} while (!constraint.allows(gx,gz) && r < halfSize);
group = new RandomGroup(
[ new SimpleObject(oGiraffe, 2,4, 0,3), // select from these groups randomly
new SimpleObject(oWildebeest, 3,5, 0,3),
new SimpleObject(oGazelle, 5,7, 0,3)
], true, clFood, gx, gz
);
createObjectGroup(group, 0);
createObjectGroup(
new RandomGroup(
[ new SimpleObject(oGiraffe, 2,4, 0,3),
new SimpleObject(oWildebeest, 3,5, 0,3),
new SimpleObject(oGazelle, 5,7, 0,3)
],
true,
clFood,
gx,
gz),
0);
}
constraint = new AndConstraint([borderClasses(clForest, 15, 0), avoidClasses(clFood, 5)]);
@ -215,79 +224,76 @@ for (var i = 0; i < num; ++i)
RMS.SetProgress(35);
log("Creating level 1 hills...");
placer = new ClumpPlacer(scaleByMapSize(50,300), 0.25, 0.1, 0.5);
var terrainPainter = new LayeredPainter(
[tCliff, tSand], // terrains
[1] // widths
);
var elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, 16, 1);
var hillAreas = createAreas(placer, [terrainPainter, elevationPainter, paintClass(clHill1)],
var hillAreas = createAreas(
new ClumpPlacer(scaleByMapSize(50,300), 0.25, 0.1, 0.5),
[
new LayeredPainter([tCliff, tSand], [1]),
new SmoothElevationPainter(ELEVATION_MODIFY, 16, 1),
paintClass(clHill1)
],
avoidClasses(clForest, 3, clPlayer, 0, clHill1, 10),
scaleByMapSize(10,20), 100
);
RMS.SetProgress(40);
log("Creating small level 1 hills...");
placer = new ClumpPlacer(scaleByMapSize(25,150), 0.25, 0.1, 0.5);
terrainPainter = new LayeredPainter(
[tCliff, tSand], // terrains
[1] // widths
);
elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, 16, 1);
var tempAreas = createAreas(placer, [terrainPainter, elevationPainter, paintClass(clHill1)],
avoidClasses(clForest, 3, clPlayer, 0, clHill1, 3),
scaleByMapSize(15,25), 100
);
for (var i = 0; i < tempAreas.length; ++i)
hillAreas.push(tempAreas[i]);
hillAreas = hillAreas.concat(
createAreas(
new ClumpPlacer(scaleByMapSize(25,150), 0.25, 0.1, 0.5),
[
new LayeredPainter([tCliff, tSand], [1]),
new SmoothElevationPainter(ELEVATION_MODIFY, 16, 1),
paintClass(clHill1)
],
avoidClasses(clForest, 3, clPlayer, 0, clHill1, 3),
scaleByMapSize(15,25),
100));
RMS.SetProgress(45);
log("Creating decorative rocks...");
group = new SimpleGroup(
[new RandomObject([aDecorativeRock, aBush2, aBush3], 3,8, 0,2)],
true
);
createObjectGroupsByAreasDeprecated(group, 0,
createObjectGroupsByAreasDeprecated(
new SimpleGroup(
[new RandomObject([aDecorativeRock, aBush2, aBush3], 3, 8, 0, 2)],
true),
0,
borderClasses(clHill1, 0, 3),
scaleByMapSize(40,200), 50,
hillAreas
);
hillAreas);
RMS.SetProgress(50);
log("Creating level 2 hills...");
placer = new ClumpPlacer(scaleByMapSize(25,150), 0.25, 0.1, 0);
terrainPainter = new LayeredPainter(
[tCliff, tSand], // terrains
[1] // widths
);
elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, 16, 1);
createAreasInAreas(placer, [terrainPainter, elevationPainter],
createAreasInAreas(
new ClumpPlacer(scaleByMapSize(25, 150), 0.25, 0.1, 0),
[
new LayeredPainter([tCliff, tSand], [1]),
new SmoothElevationPainter(ELEVATION_MODIFY, 16, 1)
],
[stayClasses(clHill1, 0)],
scaleByMapSize(15,25), 50,
hillAreas
);
scaleByMapSize(15, 25),
50,
hillAreas);
RMS.SetProgress(55);
log("Creating level 3 hills...");
placer = new ClumpPlacer(scaleByMapSize(12, 75), 0.25, 0.1, 0);
terrainPainter = new LayeredPainter(
[tCliff, tSand], // terrains
[1] // widths
);
elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, 16, 1);
createAreas(placer, [terrainPainter, elevationPainter],
createAreas(
new ClumpPlacer(scaleByMapSize(12, 75), 0.25, 0.1, 0),
[
new LayeredPainter([tCliff, tSand], [1]),
new SmoothElevationPainter(ELEVATION_MODIFY, 16, 1)
],
[stayClasses(clHill1, 0)],
scaleByMapSize(15,25), 50
scaleByMapSize(15,25),
50
);
RMS.SetProgress(60);
log("Creating bumps...");
placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 0);
elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2);
createAreas(
placer,
elevationPainter,
new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 0),
new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2),
avoidClasses(clForest, 0, clPlayer, 0, clHill1, 2),
scaleByMapSize(100, 200)
);
@ -315,7 +321,7 @@ createAreas(placer, [painter, paintClass(clForest)],
RMS.SetProgress(70);
log("Creating stone mines...");
group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4), new RandomObject(aBushes, 2,4, 0,2)], true, clRock);
var group = new SimpleGroup([new SimpleObject(oStoneSmall, 0, 2, 0, 4), new SimpleObject(oStoneLarge, 1, 1, 0, 4), new RandomObject(aBushes, 2, 4, 0, 2)], true, clRock);
createObjectGroupsDeprecated(group, 0,
[avoidClasses(clForest, 1, clPlayer, 10, clRock, 10, clHill1, 1)],
scaleByMapSize(4,16), 100
@ -359,16 +365,14 @@ createObjectGroupsDeprecated(group, 0,
RMS.SetProgress(85);
log("Creating straggler trees...");
var types = [oDatePalm, oSDatePalm]; // some variation
var types = [oDatePalm, oSDatePalm];
var num = floor(numStragglers / types.length);
for (var i = 0; i < types.length; ++i)
{
group = new SimpleGroup([new SimpleObject(types[i], 1,1, 0,0)], true);
createObjectGroupsDeprecated(group, 0,
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
);
}
num);
RMS.SetProgress(90);
log("Creating bushes...");

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

@ -134,37 +134,28 @@ paintRiver({
log("Creating shores...");
for (var i = 0; i < scaleByMapSize(20,120); i++)
{
placer = new ChainPlacer(
1,
Math.floor(scaleByMapSize(4, 6)),
Math.floor(scaleByMapSize(16, 30)),
1,
randIntExclusive(0.1 * mapSize, 0.9 * mapSize),
randIntExclusive(0.67 * mapSize, 0.74 * mapSize));
var terrainPainter = new LayeredPainter(
[tSnowA, tSnowA], // terrains
[2] // widths
);
var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 3);
createArea(
placer,
[terrainPainter, elevationPainter, unPaintClass(clWater)],
null
);
}
new ChainPlacer(
1,
Math.floor(scaleByMapSize(4, 6)),
Math.floor(scaleByMapSize(16, 30)),
1,
randIntExclusive(0.1 * mapSize, 0.9 * mapSize),
randIntExclusive(0.67 * mapSize, 0.74 * mapSize)),
[
new LayeredPainter([tSnowA, tSnowA], [2]),
new SmoothElevationPainter(ELEVATION_SET, 3, 3), unPaintClass(clWater)
],
null);
log("Creating islands...");
placer = new ChainPlacer(1, floor(scaleByMapSize(4, 6)), floor(scaleByMapSize(16, 40)), 0.1);
var terrainPainter = new LayeredPainter(
[tSnowA, tSnowA], // terrains
[3] // widths
);
var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 3, 3);
createAreas(
placer,
[terrainPainter, elevationPainter, unPaintClass(clWater)],
new ChainPlacer(1, Math.floor(scaleByMapSize(4, 6)), Math.floor(scaleByMapSize(16, 40)), 0.1),
[
new LayeredPainter([tSnowA, tSnowA], [3]),
new SmoothElevationPainter(ELEVATION_SET, 3, 3),
unPaintClass(clWater)
],
stayClasses(clWater, 7),
scaleByMapSize(10, 80)
);
@ -172,19 +163,15 @@ createAreas(
paintTerrainBasedOnHeight(-6, 1, 1, tWater);
log("Creating lakes...");
var numLakes = round(scaleByMapSize(1,4) * numPlayers);
var placer = new ChainPlacer(1, floor(scaleByMapSize(5, 7)), floor(scaleByMapSize(20, 50)), 0.1);
var terrainPainter = new LayeredPainter(
[tShoreBlend, tShore, tWater], // terrains
[1,1] // widths
);
var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -4, 3);
var waterAreas = createAreas(
placer,
[terrainPainter, elevationPainter, paintClass(clWater)],
createAreas(
new ChainPlacer(1, Math.floor(scaleByMapSize(5, 7)), Math.floor(scaleByMapSize(20, 50)), 0.1),
[
new LayeredPainter([tShoreBlend, tShore, tWater], [1, 1]),
new SmoothElevationPainter(ELEVATION_SET, -4, 3),
paintClass(clWater)
],
avoidClasses(clPlayer, 20, clWater, 20),
numLakes
);
Math.round(scaleByMapSize(1, 4) * numPlayers));
paintTerrainBasedOnHeight(1, 2.8, 1, tShoreBlend);
paintTileClassBasedOnHeight(-6, 0.5, 1, clWater);
@ -192,21 +179,18 @@ paintTileClassBasedOnHeight(-6, 0.5, 1, clWater);
RMS.SetProgress(45);
log("Creating hills...");
placer = new ChainPlacer(1, floor(scaleByMapSize(4, 6)), floor(scaleByMapSize(16, 40)), 0.1);
var terrainPainter = new LayeredPainter(
[tCliff, tSnowA], // terrains
[3] // widths
);
var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 25, 3);
createAreas(
placer,
[terrainPainter, elevationPainter, paintClass(clHill)],
new ChainPlacer(1, Math.floor(scaleByMapSize(4, 6)), Math.floor(scaleByMapSize(16, 40)), 0.1),
[
new LayeredPainter([tCliff, tSnowA], [3]),
new SmoothElevationPainter(ELEVATION_SET, 25, 3),
paintClass(clHill)
],
avoidClasses(clPlayer, 20, clHill, 15, clWater, 2, clBaseResource, 2),
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;
@ -219,69 +203,63 @@ log("Creating forests...");
var types = [
[[tSnowA, tSnowA, tSnowA, tSnowA, pForestD], [tSnowA, tSnowA, tSnowA, pForestD]],
[[tSnowA, tSnowA, tSnowA, tSnowA, pForestS], [tSnowA, tSnowA, tSnowA, pForestS]]
]; // some variation
];
var size = numForest / (scaleByMapSize(3,6) * numPlayers);
var num = floor(size / types.length);
for (var i = 0; i < types.length; ++i)
{
placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), numForest / (num * floor(scaleByMapSize(2,4))), 1);
painter = new LayeredPainter(
types[i], // terrains
[2] // widths
);
for (let type of types)
createAreas(
placer,
[painter, paintClass(clForest)],
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), numForest / (num * Math.floor(scaleByMapSize(2, 4))), 1),
[
new LayeredPainter(type, [2]),
paintClass(clForest)
],
avoidClasses(clPlayer, 20, clForest, 20, clHill, 0, clWater, 8),
num
);
}
num);
log("Creating iceberg...");
group = new SimpleGroup([new SimpleObject(aIceberg, 0,2, 0,4)], true, clRock);
createObjectGroupsDeprecated(group, 0,
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(aIceberg, 0, 2, 0, 4)], true, clRock),
0,
[avoidClasses(clRock, 6), stayClasses(clWater, 4)],
scaleByMapSize(4,16), 100
);
scaleByMapSize(4, 16),
100);
RMS.SetProgress(70);
log("Creating dirt patches...");
var sizes = [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)];
for (var i = 0; i < sizes.length; i++)
{
placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
painter = new LayeredPainter(
[tSnowD,tSnowB,tSnowC], // terrains
[2,1] // widths
);
for (let size of [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)])
createAreas(
placer,
[painter, paintClass(clDirt)],
avoidClasses(clWater, 8, clForest, 0, clHill, 0, clPlayer, 20, clDirt, 16),
scaleByMapSize(20, 80)
);
}
var sizes = [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)];
for (var i = 0; i < sizes.length; i++)
{
placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
painter = new LayeredPainter(
[tSnowE,tSnowE], // terrains
[1] // widths
);
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
[
new LayeredPainter([tSnowD, tSnowB, tSnowC], [2, 1]),
paintClass(clDirt)
],
avoidClasses(
clWater, 8,
clForest, 0,
clHill, 0,
clPlayer, 20,
clDirt, 16),
scaleByMapSize(20, 80));
for (let size of [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)])
createAreas(
placer,
[painter, paintClass(clDirt)],
avoidClasses(clWater, 8, clForest, 0, clHill, 0, clPlayer, 20, clDirt, 16),
scaleByMapSize(20, 80)
);
}
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
[
new LayeredPainter([tSnowE, tSnowE], [1]),
paintClass(clDirt)
],
avoidClasses(
clWater, 8,
clForest, 0,
clHill, 0,
clPlayer, 20,
clDirt, 16),
scaleByMapSize(20, 80));
log("Creating stone mines...");
group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
var group = new SimpleGroup([new SimpleObject(oStoneSmall, 0, 2, 0, 4), new SimpleObject(oStoneLarge, 1, 1, 0, 4)], true, clRock);
createObjectGroupsDeprecated(group, 0,
avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clRock, 10, clHill, 1),
scaleByMapSize(8,32), 100
@ -303,19 +281,14 @@ createObjectGroupsDeprecated(group, 0,
RMS.SetProgress(95);
log("Creating straggler trees...");
var types = [oPine]; // some variation
var types = [oPine];
var num = floor(numStragglers / types.length);
for (var i = 0; i < types.length; ++i)
{
group = new SimpleGroup(
[new SimpleObject(types[i], 1,1, 0,3)],
true, clForest
);
createObjectGroupsDeprecated(group, 0,
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
);
}
num);
log("Creating deer...");
group = new SimpleGroup(

159
binaries/data/mods/public/maps/random/oasis.js
View file

@ -129,87 +129,118 @@ for (var i = 0; i < numPlayers; i++)
true, clBaseResource, mX, mZ
);
createObjectGroup(group, 0);
// Create starting batches of wood
var types = [tForestFloor, pForestMain]; // some variation
var forestX = 0;
var forestY = 0;
var forestAngle = 0;
let forestX = 0;
let forestY = 0;
let forestAngle = 0
let forestDist = radius * 1.2;
do {
forestAngle = mAngle + randFloat(PI/2, (2*PI)/3);
var forestDist = radius * 1.2;
forestX = round(fx + forestDist * cos(forestAngle));
forestY = round(fz + forestDist * sin(forestAngle));
placer = new ClumpPlacer(70, 1.0, 0.5, 10,forestX,forestY);
painter = new LayeredPainter(types, [0] );
} while (createArea( placer, [painter, paintClass(clBaseResource)], avoidClasses(clBaseResource, 0) ) === undefined);
// creating the water patch explaining the forest
forestAngle = Math.PI / 3 * randFloat(1, 2);
forestX = Math.round(fx + forestDist * Math.cos(forestAngle));
forestY = Math.round(fz + forestDist * Math.sin(forestAngle));
} while (
!createArea(
new ClumpPlacer(70, 1, 0.5, 10, forestX, forestY),
[
new LayeredPainter([tForestFloor, pForestMain], [0]),
paintClass(clBaseResource)
],
avoidClasses(clBaseResource, 0)));
// Creating the water patch explaining the forest
do {
var watAngle = forestAngle + randFloat((PI/3), (5*PI/3));
var watX = round(forestX + 6 * cos(watAngle));
var watY = round(forestY + 6 * sin(watAngle));
placer = new ClumpPlacer(60, 0.9, 0.4, 5,watX,watY);
terrainPainter = new LayeredPainter( [tShore,tShoreBlend], [1] );
painter = new SmoothElevationPainter(ELEVATION_MODIFY, -5, 3);
group = new SimpleGroup( [new SimpleObject(aFlower1, 1,5, 0,3)], true, undefined, round(forestX + 3 * cos(watAngle)),round(forestY + 3 * sin(watAngle)) );
createObjectGroup(group, 0);
group = new SimpleGroup( [new SimpleObject(aReedsA, 1,3, 0,0)], true, undefined, round(forestX + 5 * cos(watAngle)),round(forestY + 5 * sin(watAngle)) );
createObjectGroup(group, 0);
} while (createArea( placer, [terrainPainter, painter], avoidClasses(clBaseResource,0) ) === undefined);
// TODO: add a few random trees here and there
createObjectGroup(
new SimpleGroup(
[new SimpleObject(aFlower1, 1, 5, 0, 3)],
true,
undefined,
Math.round(forestX + 3 * Math.cos(watAngle)),
Math.round(forestY + 3 * Math.sin(watAngle))),
0);
createObjectGroup(
new SimpleGroup(
[new SimpleObject(aReedsA, 1, 3, 0, 0)],
true,
undefined,
Math.round(forestX + 5 * Math.cos(watAngle)),
Math.round(forestY + 5 * Math.sin(watAngle))),
0);
} while (
!createArea(
new ClumpPlacer(60, 0.9, 0.4, 5, watX, watY),
[
new LayeredPainter([tShore, tShoreBlend], [1]),
new SmoothElevationPainter(ELEVATION_MODIFY, -5, 3)
],
avoidClasses(clBaseResource, 0)));
}
RMS.SetProgress(20);
log("Creating bumps...");
placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1);
painter = new SmoothElevationPainter(ELEVATION_MODIFY, 4, 3);
createAreas( placer, painter,
avoidClasses(clPlayer, 10, clBaseResource, 6),
scaleByMapSize(30, 70)
);
createAreas(
new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1),
new SmoothElevationPainter(ELEVATION_MODIFY, 4, 3),
avoidClasses(clPlayer, 10, clBaseResource, 6),
scaleByMapSize(30, 70));
log("Creating dirt Patches...");
placer = new ClumpPlacer(80, 0.3, 0.06, 1);
var terrainPainter = new TerrainPainter(tDirt);
createAreas(placer, terrainPainter, avoidClasses(clPlayer, 10, clBaseResource, 6), scaleByMapSize(15, 50) );
createAreas(
new ClumpPlacer(80, 0.3, 0.06, 1),
new TerrainPainter(tDirt),
avoidClasses(clPlayer, 10, clBaseResource, 6),
scaleByMapSize(15, 50));
log("Creating Dunes...");
placer = new ClumpPlacer(120, 0.3, 0.06, 1);
var terrainPainter = new TerrainPainter(tDune);
painter = new SmoothElevationPainter(ELEVATION_MODIFY, 18, 30);
createAreas( placer, [terrainPainter, painter],
avoidClasses(clPlayer, 10, clBaseResource, 6),
scaleByMapSize(15, 50)
);
createAreas(
new ClumpPlacer(120, 0.3, 0.06, 1),
[
new TerrainPainter(tDune),
new SmoothElevationPainter(ELEVATION_MODIFY, 18, 30)
],
avoidClasses(clPlayer, 10, clBaseResource, 6),
scaleByMapSize(15, 50));
log("Creating actual oasis...");
var size = mapSize * 0.2;
size *= size;
//var lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 6))));
fx = fractionToTiles(0.5);
fz = fractionToTiles(0.5);
ix = round(fx);
iz = round(fz);
placer = new ClumpPlacer(size*1.1, 0.8, 0.2, 10, ix, iz);
terrainPainter = new LayeredPainter( [pOasisForestLight,tShoreBlend, tWater, tWater, tWater], [scaleByMapSize(6,20),3, 5, 2] );
var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -3, 15 );
createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], null);
var fx = fractionToTiles(0.5);
var fz = fractionToTiles(0.5);
createArea(
new ClumpPlacer(Math.pow(mapSize * 0.2, 2) * 1.1, 0.8, 0.2, 10, Math.round(fx), Math.round(fz)),
[
new LayeredPainter([pOasisForestLight,tShoreBlend, tWater, tWater, tWater], [scaleByMapSize(6, 20), 3, 5, 2]),
new SmoothElevationPainter(ELEVATION_SET, -3, 15),
paintClass(clWater)
],
null);
RMS.SetProgress(50);
if (mapSize > 150 && randBool())
{
log ("creating path through");
log("Creating path though the oasis...");
var pAngle = randFloat(0, TWO_PI);
var px = round(fx) + round(fractionToTiles(0.13 * cos(pAngle)));
var py = round(fz) + round(fractionToTiles(0.13 * sin(pAngle)));
var pex = round(fx) + round(fractionToTiles(0.13 * -cos(pAngle)));
var pey = round(fz) + round(fractionToTiles(0.13 * sin(pAngle + PI)));
var path = new PathPlacer(px,py,pex,pey,scaleByMapSize(7,18), 0.4, 1, 0.2, 0);
terrainPainter = new TerrainPainter(tSand);
elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, 4, 5 );
createArea(path, [terrainPainter, elevationPainter, paintClass(clPassage)], null);
createArea(
new PathPlacer(px, py, pex, pey, scaleByMapSize(7, 18), 0.4, 1, 0.2, 0),
[
new TerrainPainter(tSand),
new SmoothElevationPainter(ELEVATION_MODIFY, 4, 5),
paintClass(clPassage)
],
null);
}
log("Creating some straggler trees around the Passage...");
group = new SimpleGroup([new SimpleObject(ePalmTall, 1,1, 0,0),new SimpleObject(ePalmShort, 1,2, 1,2), new SimpleObject(aBushA, 0,2, 1,3)], true, clForest);
createObjectGroupsDeprecated(group, 0, stayClasses(clPassage,1), scaleByMapSize(60,250), 100 );
var group = new SimpleGroup([new SimpleObject(ePalmTall, 1,1, 0,0),new SimpleObject(ePalmShort, 1, 2, 1, 2), new SimpleObject(aBushA, 0,2, 1,3)], true, clForest);
createObjectGroupsDeprecated(group, 0, stayClasses(clPassage, 1), scaleByMapSize(60, 250), 100);
log("Creating stone mines...");
group = new SimpleGroup([new SimpleObject(eStoneMine, 1,1, 0,0),new SimpleObject(ePalmShort, 1,2, 3,3),new SimpleObject(ePalmTall, 0,1, 3,3)
@ -259,8 +290,6 @@ RMS.SetProgress(85);
log("Creating Oasis Animals...");
for (var p = 0; p < scaleByMapSize(5,30); p++)
{
fx = fractionToTiles(0.5);
fz = fractionToTiles(0.5);
var aAngle = randFloat(0, TWO_PI);
var aDist = fractionToTiles(0.11);
var animX = round(fx + aDist * cos(aAngle));
@ -269,21 +298,8 @@ for (var p = 0; p < scaleByMapSize(5,30); p++)
[new SimpleObject(eLion, 1,2, 0,4),new SimpleObject(eLioness, 1,2, 2,4),new SimpleObject(eGazelle, 4,6, 1,5),new SimpleObject(eCamel, 1,2, 1,5)], true, clFood, animX,animY);
createObjectGroup(group, 0);
}
/*
var planetm = 8;
log("Creating small grass tufts...");
group = new SimpleGroup(
[new SimpleObject(rba1, 1,2, 0,1, -PI/8,PI/8)]
);
createObjectGroupsDeprecated(group, 0,
avoidClasses(clWater, 2, clHill, 2, clPlayer, 2, clDirt, 0),
planetm * scaleByMapSize(13, 200)
);
*/
RMS.SetProgress(90);
RMS.SetProgress(95);
log("Creating bushes...");
group = new SimpleGroup(
[new SimpleObject(aBushB, 1,2, 0,2), new SimpleObject(aBushA, 2,4, 0,2)]
@ -303,7 +319,8 @@ for (var sandx = 0; sandx < mapSize; sandx += 4)
group = new SimpleGroup( [new SimpleObject(aSand, 0,1, 0,2)], true, undefined, sandx,sandz );
createObjectGroup(group, 0);
}
} else if (getHeight(sandx,sandz) > -2.5 && getHeight(sandx,sandz) < -1.0)
}
else if (getHeight(sandx, sandz) > -2.5 && getHeight(sandx,sandz) < -1)
{
if (randBool(0.4))
{

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

@ -148,49 +148,63 @@ for (var i = 0; i < numPlayers; i++)
RMS.SetProgress(10);
log("Creating rock patches...");
placer = new ChainPlacer(1, floor(scaleByMapSize(3, 6)), floor(scaleByMapSize(20, 45)), 0);
painter = new TerrainPainter(tRocky);
createAreas(placer, [painter, paintClass(clPatch)],
createAreas(
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 6)), Math.floor(scaleByMapSize(20, 45)), 0),
[
new TerrainPainter(tRocky),
paintClass(clPatch)
],
avoidClasses(clPatch, 2, clPlayer, 0),
scaleByMapSize(5, 20)
);
scaleByMapSize(5, 20));
RMS.SetProgress(15);
var placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), floor(scaleByMapSize(15, 40)), 0);
var painter = new TerrainPainter([tRocky, tRocks]);
createAreas(placer, [painter, paintClass(clPatch)],
log("Creating secondary rock patches...");
createAreas(
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), Math.floor(scaleByMapSize(15, 40)), 0),
[
new TerrainPainter([tRocky, tRocks]),
paintClass(clPatch)
],
avoidClasses(clPatch, 2, clPlayer, 4),
scaleByMapSize(15, 50)
);
scaleByMapSize(15, 50));
RMS.SetProgress(20);
log("Creating dirt patches...");
placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), floor(scaleByMapSize(15, 40)), 0);
painter = new TerrainPainter([tGrass]);
createAreas(placer, [painter, paintClass(clPatch)],
createAreas(
new ChainPlacer(
1,
Math.floor(scaleByMapSize(3, 5)),
Math.floor(scaleByMapSize(15, 40)),
0),
[
new TerrainPainter([tGrass]),
paintClass(clPatch)
],
avoidClasses(clPatch, 2, clPlayer, 4),
scaleByMapSize(15, 50)
);
scaleByMapSize(15, 50));
RMS.SetProgress(25);
log("Creating centeral plateau...");
var halfSize = mapSize / 2;
var oRadius = scaleByMapSize(18, 68);
placer = new ChainPlacer(2, floor(scaleByMapSize(5, 13)), floor(scaleByMapSize(35, 200)), 1, halfSize, halfSize, 0, [floor(oRadius)]);
painter = new LayeredPainter([tLakebed2, tLakebed1], [6]);
var elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, -10, 8);
createArea(placer, [painter, elevationPainter, paintClass(clCP)], avoidClasses(clPlayer, 18));
createArea(
new ChainPlacer(
2,
Math.floor(scaleByMapSize(5, 13)),
Math.floor(scaleByMapSize(35, 200)),
1,
mapSize / 2,
mapSize / 2,
0,
[Math.floor(scaleByMapSize(18, 68))]),
[
new LayeredPainter([tLakebed2, tLakebed1], [6]),
new SmoothElevationPainter(ELEVATION_MODIFY, -10, 8),
paintClass(clCP)
],
avoidClasses(clPlayer, 18));
RMS.SetProgress(30);
log("Creating hills...");
var numHills = scaleByMapSize(20, 80);
for (var i = 0; i < numHills; ++i)
{
for (let i = 0; i < scaleByMapSize(20, 80); ++i)
createMountain(
floor(scaleByMapSize(40, 60)),
floor(scaleByMapSize(3, 4)),
@ -201,10 +215,7 @@ for (var i = 0; i < numHills; ++i)
randIntExclusive(0, mapSize),
tCliff,
clHill,
14
);
}
14);
RMS.SetProgress(35);
// calculate desired number of trees for map (based on size)
@ -220,27 +231,30 @@ log("Creating forests...");
var types = [
[[tDirtMain, tForestFloor, pForestO], [tForestFloor, pForestO]],
[[tDirtMain, tForestFloor, pForestO], [tForestFloor, pForestO]]
]; // some variation
];
var size = numForest / (scaleByMapSize(3,6) * numPlayers);
var num = floor(size / types.length);
for (var i = 0; i < types.length; ++i)
{
placer = new ChainPlacer(floor(scaleByMapSize(1, 2)), floor(scaleByMapSize(2, 5)), floor(size / floor(scaleByMapSize(8, 3))), 1);
painter = new LayeredPainter(
types[i], // terrains
[2] // widths
);
for (let type of types)
createAreas(
placer,
[painter, paintClass(clForest)],
avoidClasses(clPlayer, 6, clForest, 10, clHill, 1, clCP, 1),
num
);
}
new ChainPlacer(
Math.floor(scaleByMapSize(1, 2)),
Math.floor(scaleByMapSize(2, 5)),
Math.floor(size / Math.floor(scaleByMapSize(8, 3))),
1),
[
new LayeredPainter(type, [2]),
paintClass(clForest)
],
avoidClasses(
clPlayer, 6,
clForest, 10,
clHill, 1,
clCP, 1),
num);
RMS.SetProgress(50);
log("Creating stone mines...");
group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4), new RandomObject(aBushes, 2,4, 0,2)], true, clRock);
var group = new SimpleGroup([new SimpleObject(oStoneSmall, 0, 2, 0, 4), new SimpleObject(oStoneLarge, 1, 1, 0, 4), new RandomObject(aBushes, 2, 4, 0, 2)], true, clRock);
createObjectGroupsDeprecated(group, 0,
[avoidClasses(clForest, 1, clPlayer, 10, clRock, 10, clHill, 1, clCP, 1)],
scaleByMapSize(2,8), 100
@ -352,19 +366,24 @@ createObjectGroupsDeprecated(group, 0,
RMS.SetProgress(90);
log("Creating straggler trees...");
var types = [oOak]; // some variation
var types = [oOak];
var num = floor(numStragglers / types.length);
for (var i = 0; i < types.length; ++i)
{
group = new SimpleGroup(
[new SimpleObject(types[i], 1,1, 0,3)],
true, clForest
);
createObjectGroupsDeprecated(group, 0,
avoidClasses(clForest, 1, clHill, 1, clPlayer, 1, clMetal, 6, clRock, 6, clCP, 2),
num
);
}
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);
setSunColor(1.0, 0.796, 0.374);
setSunElevation(PI / 6);

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

@ -163,28 +163,22 @@ paintRiver({
RMS.SetProgress(40);
log("Creating bumps...");
placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1);
painter = new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2);
createAreas(
placer,
painter,
new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1),
new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2),
avoidClasses(clWater, 2, clPlayer, 20),
scaleByMapSize(100, 200)
);
scaleByMapSize(100, 200));
log("Creating hills...");
placer = new ChainPlacer(1, floor(scaleByMapSize(4, 6)), floor(scaleByMapSize(16, 40)), 0.5);
var terrainPainter = new LayeredPainter(
[tCliff, tHill], // terrains
[2] // widths
);
var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 15, 2);
createAreas(
placer,
[terrainPainter, elevationPainter, paintClass(clHill)],
new ChainPlacer(1, Math.floor(scaleByMapSize(4, 6)), Math.floor(scaleByMapSize(16, 40)), 0.5),
[
new LayeredPainter([tCliff, tHill], [2]),
new SmoothElevationPainter(ELEVATION_SET, 15, 2),
paintClass(clHill)
],
avoidClasses(clPlayer, 20, clForest, 1, clHill, 15, clWater, 0),
scaleByMapSize(1, 4) * numPlayers * 3
);
scaleByMapSize(1, 4) * numPlayers * 3);
// calculate desired number of trees for map (based on size)
const MIN_TREES = 500;
@ -197,66 +191,58 @@ var numStragglers = totalTrees * (1.0 - P_FOREST);
log("Creating forests...");
var num = scaleByMapSize(10,42);
placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), numForest / (num * floor(scaleByMapSize(2,5))), 0.5);
painter = new TerrainPainter([tForestFloor, pForest]);
createAreas(placer, [painter, paintClass(clForest)],
createAreas(
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), numForest / (num * Math.floor(scaleByMapSize(2, 5))), 0.5),
[
new TerrainPainter([tForestFloor, pForest]),
paintClass(clForest)
],
avoidClasses(clPlayer, 20, clForest, 10, clWater, 1, clHill, 1, clBaseResource, 3),
num, 50
);
num,
50);
RMS.SetProgress(50);
log("Creating grass patches...");
var sizes = [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)];
for (var i = 0; i < sizes.length; i++)
{
placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
painter = new LayeredPainter(
[[tGrass,tRocksShrubs],[tRocksShrubs,tRocksGrass], [tRocksGrass,tGrass]], // terrains
[1,1] // widths
);
for (let size of [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)])
createAreas(
placer,
[painter, paintClass(clDirt)],
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
[
new LayeredPainter(
[[tGrass, tRocksShrubs], [tRocksShrubs, tRocksGrass], [tRocksGrass, tGrass]],
[1, 1]),
paintClass(clDirt)
],
avoidClasses(clForest, 0, clGrass, 5, clPlayer, 10, clWater, 4, clDirt, 5, clHill, 1),
scaleByMapSize(15, 45)
);
}
scaleByMapSize(15, 45));
RMS.SetProgress(55);
log("Creating dirt patches...");
var sizes = [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)];
for (var i = 0; i < sizes.length; i++)
{
placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
painter = new LayeredPainter(
[[tDirt,tDirtB],[tDirt,tMainDirt], [tDirtB,tMainDirt]], // terrains
[1,1] // widths
);
for (let size of [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)])
createAreas(
placer,
[painter, paintClass(clDirt)],
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
[
new LayeredPainter(
[[tDirt, tDirtB], [tDirt, tMainDirt], [tDirtB, tMainDirt]],
[1, 1]),
paintClass(clDirt)
],
avoidClasses(clForest, 0, clDirt, 5, clPlayer, 10, clWater, 4, clGrass, 5, clHill, 1),
scaleByMapSize(15, 45)
);
}
scaleByMapSize(15, 45));
RMS.SetProgress(60);
log("Creating cyprus...");
placer = new ClumpPlacer(4.5 * scaleByMapSize(60, 540), 0.2, 0.1, 0.01);
var terrainPainter = new LayeredPainter(
[tShore, tHill], // terrains
[12] // widths
);
var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 6, 8);
createAreas(
placer,
[terrainPainter, elevationPainter, paintClass(clIsland)],
new ClumpPlacer(4.5 * scaleByMapSize(60, 540), 0.2, 0.1, 0.01),
[
new LayeredPainter([tShore, tHill], [12]),
new SmoothElevationPainter(ELEVATION_SET, 6, 8),
paintClass(clIsland)
],
[stayClasses (clWater, 5)],
1
);
1);
log("Creating cyprus stone mines...");
group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
var group = new SimpleGroup([new SimpleObject(oStoneSmall, 0, 2, 0, 4), new SimpleObject(oStoneLarge, 1, 1, 0, 4)], true, clRock);
createObjectGroupsDeprecated(group, 0,
stayClasses(clIsland, 9),
14 * scaleByMapSize(4,16), 100
@ -362,27 +348,16 @@ createObjectGroupsDeprecated(group, 0,
RMS.SetProgress(90);
log("Creating straggler trees...");
var types = [oDatePalm, oSDatePalm, oCarob, oFanPalm, oPoplar, oCypress]; // some variation
var num = floor(numStragglers / types.length);
for (var i = 0; i < types.length; ++i)
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)
{
group = new SimpleGroup([new SimpleObject(types[i], 1,1, 0,0)], true);
createObjectGroupsDeprecated(group, 0,
avoidClasses(clForest, 0, clWater, 1, clPlayer, 8, clMetal, 6, clHill, 1),
num
);
}
log("Creating straggler trees...");
var types = [oDatePalm, oSDatePalm, oCarob, oFanPalm, oPoplar, oCypress]; // some variation
var num = 3*floor(numStragglers / types.length);
for (var i = 0; i < types.length; ++i)
{
group = new SimpleGroup([new SimpleObject(types[i], 1,1, 0,0)], true);
createObjectGroupsDeprecated(group, 0,
stayClasses(clIsland, 9),
num
);
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);
}
setSkySet("sunny");

85
binaries/data/mods/public/maps/random/polar_sea.js
View file

@ -117,26 +117,22 @@ for (let i = 0; i < numPlayers; ++i)
RMS.SetProgress(30);
log("Creating central lake...");
var placer = new ChainPlacer(
2,
Math.floor(scaleByMapSize(5, 16)),
Math.floor(scaleByMapSize(35, 200)),
1,
Math.round(fractionToTiles(0.5)),
Math.round(fractionToTiles(0.5)),
0,
[Math.floor(mapSize * 0.17)]);
var terrainPainter = new LayeredPainter(
[tShore, tWater, tWater, tWater], // terrains
[1, 4, 2] // widths
);
var elevationPainter = new SmoothElevationPainter(
ELEVATION_SET, // type
-4, // elevation
4 // blend radius
);
createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 20));
createArea(
new ChainPlacer(
2,
Math.floor(scaleByMapSize(5, 16)),
Math.floor(scaleByMapSize(35, 200)),
1,
Math.round(fractionToTiles(0.5)),
Math.round(fractionToTiles(0.5)),
0,
[Math.floor(mapSize * 0.17)]),
[
new LayeredPainter([tShore, tWater, tWater, tWater], [1, 4, 2]),
new SmoothElevationPainter(ELEVATION_SET, -4, 4),
paintClass(clWater)
],
avoidClasses(clPlayer, 20));
paintTerrainBasedOnHeight(3, Math.floor(scaleByMapSize(20, 40)), 0, tCliff);
paintTerrainBasedOnHeight(Math.floor(scaleByMapSize(20, 40)), 100, 3, tSnowLimited);
@ -158,25 +154,22 @@ for (let i = 0; i < numLakes ; ++i)
if (!chosenPoint)
break;
placer = new ChainPlacer(
1,
Math.floor(scaleByMapSize(2, 4)),
Math.floor(scaleByMapSize(20, 140)),
0.7,
chosenPoint[0],
chosenPoint[1]);
let terrainPainter = new LayeredPainter(
[tShore, tWater, tWater], // terrains
[1, 3] // widths
);
let elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -5, 5);
createAreas(
placer,
[terrainPainter, elevationPainter, paintClass(clWater)],
new ChainPlacer(
1,
Math.floor(scaleByMapSize(2, 4)),
Math.floor(scaleByMapSize(20, 140)),
0.7,
chosenPoint[0],
chosenPoint[1]),
[
new LayeredPainter([tShore, tWater, tWater], [1, 3]),
new SmoothElevationPainter(ELEVATION_SET, -5, 5),
paintClass(clWater)
],
avoidClasses(clPlayer, 20),
1, 1
);
1,
1);
}
RMS.SetProgress(50);
@ -195,15 +188,13 @@ createLayeredPatches(
[scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)],
[[tDirt,tHalfSnow], [tHalfSnow,tSnowLimited]],
[2],
avoidClasses(clWater, 3, clDirt, 5, clPlayer, 12)
);
avoidClasses(clWater, 3, clDirt, 5, clPlayer, 12));
log("Creating glacier patches...");
createPatches(
[scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)],
tSecondary,
avoidClasses(clWater, 3, clDirt, 5, clPlayer, 12)
);
avoidClasses(clWater, 3, clDirt, 5, clPlayer, 12));
RMS.SetProgress(70);
log("Creating stone mines...");
@ -221,8 +212,7 @@ createMines(
[new SimpleObject(oMetalLarge, 1,1, 0,4)]
],
avoidClasses(clWater, 3, clPlayer, 20, clMetal, 18, clRock, 5, clHill, 2),
clMetal
);
clMetal);
RMS.SetProgress(75);
createDecoration(
@ -237,8 +227,7 @@ createDecoration(
scaleByMapSize(16, 262),
scaleByMapSize(8, 131),
],
avoidClasses(clWater, 0, clPlayer, 0)
);
avoidClasses(clWater, 0, clPlayer, 0));
createDecoration(
[
@ -247,8 +236,7 @@ createDecoration(
[
scaleByMapSize(8, 131)
],
[stayClasses(clWater, 4), avoidClasses(clHill, 2)]
);
[stayClasses(clWater, 4), avoidClasses(clHill, 2)]);
RMS.SetProgress(80);
createFood(
@ -296,8 +284,7 @@ createObjectGroupsDeprecated(
0,
avoidClasses(clWater, 2, clMetal, 4, clRock, 4, clPlayer, 15, clHill, 2, clWolf, 20),
1000,
100
);
100);
RMS.SetProgress(95);
if (randBool(1/3))

86
binaries/data/mods/public/maps/random/pyrenean_sierra.js
View file

@ -469,20 +469,24 @@ log ("creating Oceans");
var OceanX = fractionToTiles(0.5) + cos(MoutainAngle + lololo)*fractionToTiles(0.48);
var OceanZ = fractionToTiles(0.5) + sin(MoutainAngle + lololo)*fractionToTiles(0.48);
var radius = fractionToTiles(0.18);
var size = radius*radius*PI;
var placer = new ClumpPlacer(size, 0.9, 0.05, 10, OceanX, OceanZ);
var elevationPainter = new ElevationPainter(-22);
createArea(placer, [paintClass(clWater),elevationPainter], null);
createArea(
new ClumpPlacer(Math.PI * Math.pow(fractionToTiles(0.18), 2), 0.9, 0.05, 10, OceanX, OceanZ),
[
paintClass(clWater),
new ElevationPainter(-22)
],
null);
OceanX = fractionToTiles(0.5) + cos(PI + MoutainAngle + lololo)*fractionToTiles(0.48);
OceanZ = fractionToTiles(0.5) + sin(PI + MoutainAngle + lololo)*fractionToTiles(0.48);
radius = fractionToTiles(0.18);
size = radius*radius*PI;
placer = new ClumpPlacer(size, 0.9, 0.05, 10, OceanX, OceanZ);
elevationPainter = new ElevationPainter(-22);
createArea(placer, [paintClass(clWater),elevationPainter], null);
createArea(
new ClumpPlacer(Math.PI * Math.pow(fractionToTiles(0.18), 2), 0.9, 0.05, 10, OceanX, OceanZ),
[
new ElevationPainter(-22),
paintClass(clWater)
],
null);
// Smoothing around the water, then going a bit random
for (var ix = 1; ix < mapSize-1; ix++)
@ -523,23 +527,29 @@ for (var ix = 1; ix < mapSize-1; ix++)
}
RMS.SetProgress(55);
//create hills
log ("Creating hills...");
placer = new ClumpPlacer(scaleByMapSize(60, 120), 0.3, 0.06, 5);
painter = new SemiRandomElevationPainter(7, 4,1);
var terrainPainter = new TerrainPainter(tGrassSpecific);
createAreas( placer, [painter,terrainPainter, paintClass(clHill)], avoidClasses(clWater, 5, clPlayer, 20, clBaseResource, 6, clPyrenneans, 2), scaleByMapSize(5, 35) );
createAreas(
new ClumpPlacer(scaleByMapSize(60, 120), 0.3, 0.06, 5),
[
new SemiRandomElevationPainter(7, 4, 1),
new TerrainPainter(tGrassSpecific),
paintClass(clHill)
],
avoidClasses(clWater, 5, clPlayer, 20, clBaseResource, 6, clPyrenneans, 2), scaleByMapSize(5, 35));
log("Creating forests...");
var types = [ [tForestTransition,pForestLandVeryLight, pForestLandLight, pForestLand]];
var types = [[tForestTransition, pForestLandVeryLight, pForestLandLight, pForestLand]];
var size = scaleByMapSize(40,115)*PI;
var num = floor(scaleByMapSize(8,40) / types.length);
for (var i = 0; i < types.length; ++i)
{
placer = new ClumpPlacer(size, 0.2, 0.1, 1);
painter = new LayeredPainter( types[i], [scaleByMapSize(1,2),scaleByMapSize(3,6),scaleByMapSize(3,6)] );
createAreas( placer, [painter, paintClass(clForest)], avoidClasses(clPlayer, 20, clPyrenneans,0, clForest, 7, clWater, 2), num);
}
for (let type of types)
createAreas(
new ClumpPlacer(size, 0.2, 0.1, 1),
[
new LayeredPainter(type, [scaleByMapSize(1, 2), scaleByMapSize(3, 6), scaleByMapSize(3, 6)]),
paintClass(clForest)
],
avoidClasses(clPlayer, 20, clPyrenneans,0, clForest, 7, clWater, 2),
num);
RMS.SetProgress(60);
log("Creating lone trees...");
@ -620,22 +630,26 @@ for (var x = 0; x < mapSize; x++) {
}
}
log("Creating dirt patches...");
var sizes = [scaleByMapSize(3, 20), scaleByMapSize(5, 40), scaleByMapSize(8, 60)];
for (var i = 0; i < sizes.length; i++)
{
placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
painter = new TerrainPainter(tDirtyGrass);
createAreas( placer, [painter, paintClass(clDirt)], avoidClasses(clWater, 3, clForest, 0, clPyrenneans,5, clHill, 0, clDirt, 5, clPlayer, 6), scaleByMapSize(15, 45) );
}
for (let size of [scaleByMapSize(3, 20), scaleByMapSize(5, 40), scaleByMapSize(8, 60)])
createAreas(
new ClumpPlacer(size, 0.3, 0.06, 0.5),
[
new TerrainPainter(tDirtyGrass),
paintClass(clDirt)
],
avoidClasses(clWater, 3, clForest, 0, clPyrenneans,5, clHill, 0, clDirt, 5, clPlayer, 6),
scaleByMapSize(15, 45));
log("Creating grass patches...");
var sizes = [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)];
for (var i = 0; i < sizes.length; i++)
{
placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
painter = new TerrainPainter(tLushGrass);
createAreas( placer, [painter,paintClass(clLush)], avoidClasses(clWater, 3, clForest, 0, clPyrenneans,5, clHill, 0, clDirt, 5, clPlayer, 6), scaleByMapSize(15, 45) );
}
for (let size of [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)])
createAreas(
new ClumpPlacer(size, 0.3, 0.06, 0.5),
[
new TerrainPainter(tLushGrass),
paintClass(clLush)
],
avoidClasses(clWater, 3, clForest, 0, clPyrenneans,5, clHill, 0, clDirt, 5, clPlayer, 6),
scaleByMapSize(15, 45));
RMS.SetProgress(70);

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

@ -130,53 +130,38 @@ for (var i = 0; i < numPlayers; i++)
RMS.SetProgress(15);
log("Creating bumps...");
placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1);
painter = new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2);
createAreas(
placer,
painter,
new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1),
new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2),
avoidClasses(clPlayer, 13),
scaleByMapSize(300, 800)
);
scaleByMapSize(300, 800));
log("Creating marshes...");
for (var i = 0; i < 7; i++)
{
placer = new ChainPlacer(1, floor(scaleByMapSize(6, 12)), floor(scaleByMapSize(15, 60)), 0.8);
var terrainPainter = new LayeredPainter(
[tShoreBlend, tShore, tWater], // terrains
[1,1] // widths
);
var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -2, 3);
var waterAreas = createAreas(
placer,
[terrainPainter, elevationPainter, paintClass(clWater)],
for (let i = 0; i < 7; ++i)
createAreas(
new ChainPlacer(1, Math.floor(scaleByMapSize(6, 12)), Math.floor(scaleByMapSize(15, 60)), 0.8),
[
new LayeredPainter([tShoreBlend, tShore, tWater], [1, 1]),
new SmoothElevationPainter(ELEVATION_SET, -2, 3),
paintClass(clWater)
],
avoidClasses(clPlayer, 20, clWater, round(scaleByMapSize(7,16)*randFloat(0.8,1.35))),
scaleByMapSize(4,20)
);
}
scaleByMapSize(4,20));
log("Creating reeds...");
group = new SimpleGroup(
[new SimpleObject(aReeds, 5,10, 0,4), new SimpleObject(aLillies, 5,10, 0,4)], true
);
createObjectGroupsDeprecated(group, 0,
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(aReeds, 5, 10, 0, 4), new SimpleObject(aLillies, 5, 10, 0, 4)], true),
0,
stayClasses(clWater, 1),
scaleByMapSize(400,2000), 100
);
waterAreas = [];
scaleByMapSize(400,2000), 100);
RMS.SetProgress(40);
log("Creating bumps...");
placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1);
painter = new SmoothElevationPainter(ELEVATION_MODIFY, 1, 2);
createAreas(
placer,
painter,
new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1),
new SmoothElevationPainter(ELEVATION_MODIFY, 1, 2),
stayClasses(clWater, 2),
scaleByMapSize(50, 100)
);
scaleByMapSize(50, 100));
// calculate desired number of trees for map (based on size)
const MIN_TREES = 500;
@ -191,45 +176,33 @@ log("Creating forests...");
var types = [
[[tForestFloor, tGrass, pForestD], [tForestFloor, pForestD]],
[[tForestFloor, tGrass, pForestP], [tForestFloor, pForestP]]
]; // some variation
];
var size = numForest / (scaleByMapSize(3,6) * numPlayers);
var num = floor(size / types.length);
for (var i = 0; i < types.length; ++i)
{
placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), numForest / (num * floor(scaleByMapSize(2,4))), 1);
painter = new LayeredPainter(
types[i], // terrains
[2] // widths
);
for (let type of types)
createAreas(
placer,
[painter, paintClass(clForest)],
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), numForest / (num * Math.floor(scaleByMapSize(2, 4))), 1),
[
new LayeredPainter(type, [2]),
paintClass(clForest)
],
avoidClasses(clPlayer, 20, clWater, 0, clForest, 10, clHill, 1),
num
);
}
num);
RMS.SetProgress(50);
log("Creating mud patches...");
var sizes = [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)];
for (var i = 0; i < sizes.length; i++)
{
placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 1);
painter = new LayeredPainter(
[tGrassA, tGrassB, tMud], // terrains
[1,1] // widths
);
for (let size of [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)])
createAreas(
placer,
[painter, paintClass(clDirt)],
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 1),
[
new LayeredPainter([tGrassA, tGrassB, tMud], [1, 1]),
paintClass(clDirt)
],
avoidClasses(clWater, 1, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 8),
scaleByMapSize(15, 45)
);
}
scaleByMapSize(15, 45));
log("Creating stone mines...");
group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
var group = new SimpleGroup([new SimpleObject(oStoneSmall, 0, 2, 0, 4), new SimpleObject(oStoneLarge, 1, 1, 0, 4)], true, clRock);
createObjectGroupsDeprecated(group, 0,
[avoidClasses(clWater, 0, clForest, 1, clPlayer, 20, clRock, 10, clHill, 1)],
scaleByMapSize(4,16), 100
@ -332,52 +305,53 @@ createObjectGroupsDeprecated(group, 0,
RMS.SetProgress(80);
log("Creating straggler trees...");
var types = [oOak, oBeech]; // some variation
var types = [oOak, oBeech];
var num = floor(numStragglers / types.length);
for (var i = 0; i < types.length; ++i)
{
group = new SimpleGroup(
[new SimpleObject(types[i], 1,1, 0,3)],
true, clForest
);
createObjectGroupsDeprecated(group, 0,
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
);
}
num);
RMS.SetProgress(85);
log("Creating small grass tufts...");
group = new SimpleGroup(
[new SimpleObject(aGrassShort, 1,2, 0,1, -PI/8,PI/8)]
);
createObjectGroupsDeprecated(group, 0,
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(aGrassShort, 1, 2, 0, 1)]),
0,
avoidClasses(clWater, 2, clHill, 2, clPlayer, 13, clDirt, 0),
scaleByMapSize(13, 200)
);
scaleByMapSize(13, 200));
RMS.SetProgress(90);
log("Creating large grass tufts...");
group = new SimpleGroup(
[new SimpleObject(aGrass, 2,4, 0,1.8, -PI/8,PI/8), new SimpleObject(aGrassShort, 3,6, 1.2,2.5, -PI/8,PI/8)]
);
createObjectGroupsDeprecated(group, 0,
createObjectGroupsDeprecated(
new SimpleGroup(
[
new SimpleObject(aGrass, 2, 4, 0, 1.8),
new SimpleObject(aGrassShort, 3, 6, 1.2, 2.5)
]),
0,
avoidClasses(clWater, 3, clHill, 2, clPlayer, 13, clDirt, 1, clForest, 0),
scaleByMapSize(13, 200)
);
scaleByMapSize(13, 200));
RMS.SetProgress(95);
log("Creating bushes...");
group = new SimpleGroup(
[new SimpleObject(aBushMedium, 1,2, 0,2), new SimpleObject(aBushSmall, 2,4, 0,2)]
);
createObjectGroupsDeprecated(group, 0,
createObjectGroupsDeprecated(
new SimpleGroup(
[
new SimpleObject(aBushMedium, 1, 2, 0, 2),
new SimpleObject(aBushSmall, 2, 4, 0, 2)
]),
0,
avoidClasses(clWater, 1, clHill, 1, clPlayer, 13, clDirt, 1),
scaleByMapSize(13, 200), 50
);
scaleByMapSize(13, 200),
50);
setSkySet("cirrus");
setWaterColor(0.753,0.635,0.345); // muddy brown

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

@ -303,10 +303,9 @@ for (let type of types)
RMS.SetProgress(60);
log("Creating grass patches...");
var sizes = [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)];
for (let i = 0; i < sizes.length; ++i)
for (let size of [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)])
createAreas(
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), sizes[i], 0.5),
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
[
new LayeredPainter([tGrassC, tGrassA, tGrassB], [2, 1]),
paintClass(clDirt)
@ -321,10 +320,9 @@ for (let i = 0; i < sizes.length; ++i)
scaleByMapSize(20, 80));
log("Creating dirt patches...");
var sizes = [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)];
for (let i = 0; i < sizes.length; ++i)
for (let size of [scaleByMapSize(2, 4), scaleByMapSize(3, 7), scaleByMapSize(5, 15)])
createAreas(
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), sizes[i], 0.5),
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
[
new LayeredPainter([tPlants, tPlants], [1]),
paintClass(clDirt)

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

@ -65,24 +65,20 @@ var clShallow = createTileClass();
initTerrain(tMainTerrain);
var fx = fractionToTiles(0.5);
var fz = fractionToTiles(0.5);
ix = round(fx);
iz = round(fz);
var lSize = sqrt(sqrt(sqrt(scaleByMapSize(1, 6))));
var placer = new ClumpPlacer(mapArea * 0.01 * lSize, 0.7, 0.1, 10, ix, iz);
var terrainPainter = new LayeredPainter(
[tShore, tWater, tWater, tWater], // terrains
[1, 4, 2] // widths
);
var elevationPainter = new SmoothElevationPainter(
ELEVATION_SET, // type
-3, // elevation
4 // blend radius
);
createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], null);
createArea(
new ClumpPlacer(
mapArea / 100 * Math.pow(scaleByMapSize(1, 6), 1/8),
0.7,
0.1,
10,
Math.round(fractionToTiles(0.5)),
Math.round(fractionToTiles(0.5))),
[
new LayeredPainter([tShore, tWater, tWater, tWater], [1, 4, 2]),
new SmoothElevationPainter(ELEVATION_SET, -3, 4),
paintClass(clWater)
],
null);
var [playerIDs, playerX, playerZ, playerAngle, startAngle] = radialPlayerPlacement();
@ -104,7 +100,7 @@ for (var i = 0; i < numPlayers; i++)
// create the city patch
var cityRadius = radius/3;
placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
var placer = new ClumpPlacer(PI*cityRadius*cityRadius, 0.6, 0.3, 10, ix, iz);
var painter = new LayeredPainter([tRoadWild, tRoad], [1]);
createArea(placer, painter, null);
@ -236,13 +232,10 @@ for (var ix = 0; ix < mapSize; ix++)
var c = (PZ[m]*(PX[m]-PX[n]))-(PX[m]*(PZ[m]-PZ[n]));
var dis = abs(a*ix + b*iz + c)/sqrt(a*a + b*b);
if (abs(a*ix + b*iz + c) != 0)
{
var alamat = (a*ix + b*iz + c)/abs(a*ix + b*iz + c);
}
else
{
var alamat = 1;
}
var k = (a*ix + b*iz + c)/(a*a + b*b);
var y = iz-(b*k);
var xm = ix-(a*k);
@ -261,9 +254,8 @@ for (var ix = 0; ix < mapSize; ix++)
addToClass(ix, iz, clShallow);
}
else
{
var h = -3;
}
var t = tWater;
addToClass(ix, iz, clWater);
}
@ -279,23 +271,16 @@ for (var ix = 0; ix < mapSize; ix++)
addToClass(ix, iz, clShallow);
}
else
{
var h = 2-(sbms-dis);
}
}
else
{
var h = 2-(sbms-dis);
}
//we must create shore lines for more beautiful terrain
if (sbms-dis<=2)
{
var t = tShore;
}
else
{
var t = tWater;
}
addToClass(ix, iz, clWater);
}
//we don't want to cause problems when river joins sea
@ -438,8 +423,9 @@ createFood
RMS.SetProgress(85);
var types = [oTree1, oTree2, oTree4, oTree3]; // some variation
createStragglerTrees(types, avoidClasses(clWater, 5, clForest, 7, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6));
createStragglerTrees(
[oTree1, oTree2, oTree4, oTree3],
avoidClasses(clWater, 5, clForest, 7, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6));
setWaterWaviness(3.0);
setWaterType("lake");

2
binaries/data/mods/public/maps/random/rmbiome/randombiome.js
View file

@ -14,7 +14,7 @@ function currentBiome()
function setSelectedBiome()
{
setBiome(g_MapSettings.Biome);
setBiome(g_MapSettings.Biome || "alpine");
}
function setBiome(biomeID)

79
binaries/data/mods/public/maps/random/rmgen2/gaia.js
View file

@ -36,15 +36,15 @@ function addBluffs(constraint, size, deviation, fill, baseHeight)
{
var offset = getRandomDeviation(size, deviation);
var pMinSize = Math.floor(minSize * offset);
var pMaxSize = Math.floor(maxSize * offset);
var pSpread = Math.floor(spread * offset);
var pElevation = Math.floor(elevation * offset);
var placer = new ChainPlacer(pMinSize, pMaxSize, pSpread, 0.5);
var terrainPainter = new LayeredPainter([g_Terrains.cliff, g_Terrains.mainTerrain, constrastTerrain], [2, 3]);
var elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, pElevation, 2);
var rendered = createAreas(placer, [terrainPainter, elevationPainter, paintClass(g_TileClasses.bluff)], constraint, 1);
var rendered = createAreas(
new ChainPlacer(Math.floor(minSize * offset), Math.floor(maxSize * offset), Math.floor(spread * offset), 0.5),
[
new LayeredPainter([g_Terrains.cliff, g_Terrains.mainTerrain, constrastTerrain], [2, 3]),
new SmoothElevationPainter(ELEVATION_MODIFY, Math.floor(elevation * offset), 2),
paintClass(g_TileClasses.bluff)
],
constraint,
1);
// Find the bounding box of the bluff
if (rendered[0] === undefined)
@ -388,19 +388,20 @@ function addElevation(constraint, el)
var pElevation = Math.floor(elevation * offset);
pElevation = Math.max(el.minElevation, Math.min(pElevation, el.maxElevation));
pMinSize = Math.min(pMinSize, pMaxSize);
pMaxSize = Math.min(pMaxSize, el.maxSize);
pMinSize = Math.max(pMaxSize, el.minSize);
pSmooth = Math.max(pSmooth, 1);
var pWidths = widths.concat(pSmooth);
var placer = new ChainPlacer(pMinSize, pMaxSize, pSpread, 0.5);
var terrainPainter = new LayeredPainter(el.painter, [pWidths]);
var elevationPainter = new SmoothElevationPainter(elType, pElevation, pSmooth);
createAreas(placer, [terrainPainter, elevationPainter, paintClass(el.class)], constraint, 1);
createAreas(
new ChainPlacer(pMinSize, pMaxSize, pSpread, 0.5),
[
new LayeredPainter(el.painter, [widths.concat(pSmooth)]),
new SmoothElevationPainter(elType, pElevation, pSmooth),
paintClass(el.class)
],
constraint,
1);
}
}
@ -488,34 +489,33 @@ function addLayeredPatches(constraint, size, deviation, fill)
var maxRadius = Math.floor(scaleByMapSize(3, 5));
var count = fill * scaleByMapSize(15, 45);
var sizes = [
var patchSizes = [
scaleByMapSize(3, 6),
scaleByMapSize(5, 10),
scaleByMapSize(8, 21)
];
for (var i = 0; i < sizes.length; ++i)
for (let patchSize of patchSizes)
{
var offset = getRandomDeviation(size, deviation);
var patchMinRadius = Math.floor(minRadius * offset);
var patchMaxRadius = Math.floor(maxRadius * offset);
var patchSize = Math.floor(sizes[i] * offset);
var patchCount = count * offset;
if (patchMinRadius > patchMaxRadius)
patchMinRadius = patchMaxRadius;
var placer = new ChainPlacer(patchMinRadius, patchMaxRadius, patchSize, 0.5);
var painter = new LayeredPainter(
createAreas(
new ChainPlacer(Math.min(patchMinRadius, patchMaxRadius), patchMaxRadius, Math.floor(patchSize * offset), 0.5),
[
[g_Terrains.mainTerrain, g_Terrains.tier1Terrain],
[g_Terrains.tier1Terrain, g_Terrains.tier2Terrain],
[g_Terrains.tier2Terrain, g_Terrains.tier3Terrain],
[g_Terrains.tier4Terrain]
new LayeredPainter(
[
[g_Terrains.mainTerrain, g_Terrains.tier1Terrain],
[g_Terrains.tier1Terrain, g_Terrains.tier2Terrain],
[g_Terrains.tier2Terrain, g_Terrains.tier3Terrain],
[g_Terrains.tier4Terrain]
],
[1, 1]),
paintClass(g_TileClasses.dirt)
],
[1, 1] // widths
);
createAreas(placer, [painter, paintClass(g_TileClasses.dirt)], constraint, patchCount);
constraint,
count * offset);
}
}
@ -573,24 +573,19 @@ function addPlateaus(constraint, size, deviation, fill)
for (var i = 0; i < 40; ++i)
{
var placer = new ChainPlacer(3, 15, 1, 0.5);
var terrainPainter = new LayeredPainter([plateauTile, plateauTile], [3]);
var hillElevation = randIntInclusive(4, 18);
var elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, hillElevation, hillElevation - 2);
createAreas(
placer,
new ChainPlacer(3, 15, 1, 0.5),
[
terrainPainter,
elevationPainter,
new LayeredPainter([plateauTile, plateauTile], [3]),
new SmoothElevationPainter(ELEVATION_MODIFY, hillElevation, hillElevation - 2),
paintClass(g_TileClasses.hill)
],
[
avoidClasses(g_TileClasses.hill, 7),
stayClasses(g_TileClasses.plateau, 7)
],
1
);
1);
}
addElements([

76
binaries/data/mods/public/maps/random/saharan_oases.js
View file

@ -131,55 +131,57 @@ for (var i = 0; i < numPlayers; i++)
RMS.SetProgress(30);
for (var i = 0; i < numPlayers; i++)
{
log("Creating oases...");
var oRadius = scaleByMapSize(16, 60);
placer = new ClumpPlacer(PI*oRadius*oRadius*0.185, 0.6, 0.15, 0, mapSize*(0.5 + 0.18*cos(playerAngle[i]) + scaleByMapSize(1, 4)*cos(playerAngle[i])/100), mapSize*(0.5 + 0.18*sin(playerAngle[i]) + scaleByMapSize(1, 4)*sin(playerAngle[i])/100));
painter = new LayeredPainter([tSLush ,[tLush, pForest], [tLush, pForest], tShore, tShore, tWaterDeep], [2, 2, 1, 3, 1]);
var elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, -3, 10);
createArea(placer, [painter, elevationPainter, paintClass(clWater)], null);
}
log("Creating oases...");
for (let i = 0; i < numPlayers; ++i)
createArea(
new ClumpPlacer(Math.PI * Math.pow(scaleByMapSize(16, 60), 2) * 0.185,
0.6,
0.15,
0,
mapSize * (0.5 + 0.18 * Math.cos(playerAngle[i]) + scaleByMapSize(1, 4) * Math.cos(playerAngle[i]) / 100),
mapSize * (0.5 + 0.18 * Math.sin(playerAngle[i]) + scaleByMapSize(1, 4) * Math.sin(playerAngle[i]) / 100)),
[
new LayeredPainter(
[tSLush ,[tLush, pForest], [tLush, pForest], tShore, tShore, tWaterDeep],
[2, 2, 1, 3, 1]),
new SmoothElevationPainter(ELEVATION_MODIFY, -3, 10),
paintClass(clWater)
],
null);
RMS.SetProgress(50);
log("Creating grass patches...");
var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
for (var i = 0; i < sizes.length; i++)
{
placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
painter = new LayeredPainter(
[[tDirt1,tSandDunes],[tSandDunes,tDirt2], [tDirt2,tDirt1]], // terrains
[1,1] // widths
);
for (let size of [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)])
createAreas(
placer,
[painter, paintClass(clDirt)],
new ClumpPlacer(size, 0.3, 0.06, 0.5),
[
new LayeredPainter(
[[tDirt1, tSandDunes], [tSandDunes, tDirt2], [tDirt2, tDirt1]],
[1, 1]
),
paintClass(clDirt)
],
avoidClasses(clForest, 0, clGrass, 5, clPlayer, 0, clWater, 1, clDirt, 5),
scaleByMapSize(15, 45)
);
}
scaleByMapSize(15, 45));
RMS.SetProgress(55);
log("Creating dirt patches...");
var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
for (var i = 0; i < sizes.length; i++)
{
placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
painter = new LayeredPainter(
[[tDirt2,tDirtCracks],[tDirt2,tFineSand], [tDirtCracks,tFineSand]], // terrains
[1,1] // widths
);
for (let size of [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)])
createAreas(
placer,
[painter, paintClass(clDirt)],
new ClumpPlacer(size, 0.3, 0.06, 0.5),
[
new LayeredPainter(
[[tDirt2, tDirtCracks], [tDirt2, tFineSand], [tDirtCracks, tFineSand]],
[1, 1]
),
paintClass(clDirt)
],
avoidClasses(clForest, 0, clDirt, 5, clPlayer, 0, clWater, 1, clGrass, 5),
scaleByMapSize(15, 45)
);
}
scaleByMapSize(15, 45));
RMS.SetProgress(60);
log("Creating stone mines...");
group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
var group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
createObjectGroupsDeprecated(group, 0,
avoidClasses(clForest, 1, clPlayer, 26, clRock, 10, clWater, 1),
2*scaleByMapSize(4,16), 100

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

@ -119,49 +119,31 @@ RMS.SetProgress(20);
log("Creating big patches...");
var patches = [tGrass2, tGrass3];
for (var i = 0; i < patches.length; i++)
{
placer = new ChainPlacer(floor(scaleByMapSize(3, 6)), floor(scaleByMapSize(10, 20)), floor(scaleByMapSize(15, 60)), 1);
painter = new TerrainPainter(patches[i]);
createAreas(
placer,
painter,
new ChainPlacer(Math.floor(scaleByMapSize(3, 6)), Math.floor(scaleByMapSize(10, 20)), Math.floor(scaleByMapSize(15, 60)), 1),
new TerrainPainter(patches[i]),
avoidClasses(clPlayer, 10),
scaleByMapSize(5, 20)
);
}
scaleByMapSize(5, 20));
log("Creating small patches...");
var patches = [tDirt1, tDirt2, tDirt3];
var sizes = [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)];
for (var i = 0; i < sizes.length; i++)
{
for (var j = 0; j < patches.length; ++j)
{
placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 1);
painter = new TerrainPainter(patches[j]);
for (let size of [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)])
for (let patch of [tDirt1, tDirt2, tDirt3])
createAreas(
placer,
painter,
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 1),
new TerrainPainter(patch),
avoidClasses(clPlayer, 12),
scaleByMapSize(4, 15)
);
}
}
scaleByMapSize(4, 15));
log("Creating water holes...");
placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), floor(scaleByMapSize(20, 60)), 1);
var terrainPainter = new LayeredPainter(
[tShore, tWater], // terrains
[1] // widths
);
var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -5, 7);
createAreas(
placer,
[terrainPainter, elevationPainter, paintClass(clWater)],
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), Math.floor(scaleByMapSize(20, 60)), 1),
[
new LayeredPainter([tShore, tWater], [1]),
new SmoothElevationPainter(ELEVATION_SET, -5, 7),
paintClass(clWater)
],
avoidClasses(clPlayer, 24),
scaleByMapSize(1, 3)
);
scaleByMapSize(1, 3));
RMS.SetProgress(55);
var playerConstraint = new AvoidTileClassConstraint(clPlayer, 30);
@ -181,7 +163,7 @@ for (var i = 0; i < scaleByMapSize(12,30); ++i)
}
log("Creating metal mines...");
group = new SimpleGroup([new SimpleObject(oMetalLarge, 1,1, 0,4)], true, clMetal);
var group = new SimpleGroup([new SimpleObject(oMetalLarge, 1, 1, 0, 4)], true, clMetal);
createObjectGroupsDeprecated(group, 0,
avoidClasses(clPlayer, 20, clMetal, 10, clRock, 8, clWater, 4),
scaleByMapSize(2,8), 100

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

@ -135,25 +135,52 @@ log ("Creating rivers...");
for (var m = 0; m < numPlayers; m++)
{
var tang = startAngle + (m + 0.5) * TWO_PI / numPlayers;
placer = new ClumpPlacer(floor(PI*scaleByMapSize(10,50)*scaleByMapSize(10,50)/3), 0.95, 0.6, 10, fractionToTiles(0.5 + 0.15*cos(tang)), fractionToTiles(0.5 + 0.15*sin(tang)));
var painter = new LayeredPainter([tShore, tWater, tWater], [1, 3]);
var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -4, 4);
createArea(placer, [painter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 5));
var placer = new PathPlacer(fractionToTiles(0.5 + 0.15*cos(tang)), fractionToTiles(0.5 + 0.15*sin(tang)), fractionToTiles(0.5 + 0.49*cos(tang)), fractionToTiles(0.5 + 0.49*sin(tang)), scaleByMapSize(10,50), 0.2, 3*(scaleByMapSize(1,4)), 0.2, 0.05);
var terrainPainter = new LayeredPainter(
[tShore, tWater, tWater], // terrains
[1, 3] // widths
);
var elevationPainter = new SmoothElevationPainter(
ELEVATION_SET, // type
-4, // elevation
4 // blend radius
);
createArea(placer, [terrainPainter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 5));
placer = new ClumpPlacer(floor(PI*scaleByMapSize(10,50)*scaleByMapSize(10,50)/5), 0.95, 0.6, 10, fractionToTiles(0.5 + 0.49*cos(tang)), fractionToTiles(0.5 + 0.49*sin(tang)));
var painter = new LayeredPainter([tWater, tWater], [1]);
var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -4, 4);
createArea(placer, [painter, elevationPainter, paintClass(clWater)], avoidClasses(clPlayer, 5));
createArea(
new ClumpPlacer(
Math.floor(Math.PI * Math.pow(scaleByMapSize(10, 50), 2) / 3),
0.95,
0.6,
10,
fractionToTiles(0.5 + 0.15 * Math.cos(tang)),
fractionToTiles(0.5 + 0.15 * Math.sin(tang))),
[
new SmoothElevationPainter(ELEVATION_SET, -4, 4),
paintClass(clWater)
],
avoidClasses(clPlayer, 5));
createArea(
new PathPlacer(
fractionToTiles(0.5 + 0.15 * Math.cos(tang)),
fractionToTiles(0.5 + 0.15 * Math.sin(tang)),
fractionToTiles(0.5 + 0.49 * Math.cos(tang)),
fractionToTiles(0.5 + 0.49 * Math.sin(tang)),
scaleByMapSize(10, 50),
0.2,
3 * scaleByMapSize(1, 4),
0.2,
0.05),
[
new LayeredPainter([tShore, tWater, tWater], [1, 3]),
new SmoothElevationPainter(ELEVATION_SET, -4, 4),
paintClass(clWater)
],
avoidClasses(clPlayer, 5));
createArea(
new ClumpPlacer(
Math.floor(Math.PI * Math.pow(scaleByMapSize(10, 50), 2) / 5),
0.95,
0.6,
10,
fractionToTiles(0.5 + 0.49 * Math.cos(tang)),
fractionToTiles(0.5 + 0.49 * Math.sin(tang))),
[
new SmoothElevationPainter(ELEVATION_SET, -4, 4),
paintClass(clWater)
],
avoidClasses(clPlayer, 5));
}
for (var i = 0; i < numPlayers; i++)
@ -179,7 +206,6 @@ for (var i = 0; i < numPlayers; i++)
true, clFood, round((fractionToTiles(playerX[i]) + fractionToTiles(playerX[0]))/2), round((fractionToTiles(playerZ[i]) + fractionToTiles(playerZ[0]))/2)
);
createObjectGroup(group, 0);
}
else
{
@ -204,33 +230,26 @@ for (var i = 0; i < numPlayers; i++)
createObjectGroup(group, 0);
}
}
paintTerrainBasedOnHeight(-6, 2, 1, tWater);
log("Creating bumps...");
placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1);
painter = new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2);
createAreas(
placer,
painter,
new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1),
new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2),
avoidClasses(clWater, 2, clPlayer, 20),
scaleByMapSize(100, 200)
);
scaleByMapSize(100, 200));
log("Creating hills...");
placer = new ClumpPlacer(scaleByMapSize(20, 150), 0.2, 0.1, 1);
terrainPainter = new LayeredPainter(
[tGrass, tCliff, tHill], // terrains
[1, 2] // widths
);
elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 35, 3);
createAreas(
placer,
[terrainPainter, elevationPainter, paintClass(clHill)],
new ClumpPlacer(scaleByMapSize(20, 150), 0.2, 0.1, 1),
[
new LayeredPainter([tGrass, tCliff, tHill], [1, 2]),
new SmoothElevationPainter(ELEVATION_SET, 35, 3),
paintClass(clHill)
],
avoidClasses(clPlayer, 20, clHill, 15, clWater, 3),
scaleByMapSize(1, 4) * numPlayers
);
scaleByMapSize(1, 4) * numPlayers);
// calculate desired number of trees for map (based on size)
var MIN_TREES = 160;
@ -244,61 +263,46 @@ var numStragglers = totalTrees * (1.0 - P_FOREST);
log("Creating forests...");
var types = [
[[tForestFloor, tGrass, pForest], [tForestFloor, pForest]]
]; // some variation
];
var size = numForest / (0.5 * scaleByMapSize(2,8) * numPlayers);
var num = floor(size / types.length);
for (var i = 0; i < types.length; ++i)
{
placer = new ClumpPlacer(numForest / num, 0.1, 0.1, 1);
painter = new LayeredPainter(
types[i], // terrains
[2] // widths
);
for (let type of types)
createAreas(
placer,
[painter, paintClass(clForest)],
new ClumpPlacer(numForest / num, 0.1, 0.1, 1),
[
new LayeredPainter(type, [2]),
paintClass(clForest)
],
avoidClasses(clPlayer, 20, clForest, 10, clHill, 0, clWater, 2),
num
);
}
RMS.SetProgress(50);
log("Creating dirt patches...");
var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
for (var i = 0; i < sizes.length; i++)
{
placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
painter = new LayeredPainter(
[[tGrass,tDirtRocksA],[tDirtRocksA,tDirtRocksB], [tDirtRocksB,tDirtRocksC]], // terrains
[1,1] // widths
);
for (let size of [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)])
createAreas(
placer,
[painter, paintClass(clDirt)],
new ClumpPlacer(size, 0.3, 0.06, 0.5),
[
new LayeredPainter(
[[tGrass, tDirtRocksA], [tDirtRocksA, tDirtRocksB], [tDirtRocksB, tDirtRocksC]],
[1, 1]),
paintClass(clDirt)
],
avoidClasses(clWater, 3, clForest, 0, clHill, 0, clPlayer, 20),
scaleByMapSize(15, 45)
);
}
scaleByMapSize(15, 45));
log("Creating grass patches...");
var sizes = [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)];
for (var i = 0; i < sizes.length; i++)
{
placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
painter = new TerrainPainter(tGrassPatch);
for (let size of [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)])
createAreas(
placer,
painter,
new ClumpPlacer(size, 0.3, 0.06, 0.5),
new TerrainPainter(tGrassPatch),
avoidClasses(clWater, 3, clForest, 0, clHill, 0, clPlayer, 20),
scaleByMapSize(15, 45)
);
}
scaleByMapSize(15, 45));
RMS.SetProgress(55);
log("Creating stone mines...");
group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
var group = new SimpleGroup([new SimpleObject(oStoneSmall, 0, 2, 0, 4), new SimpleObject(oStoneLarge, 1, 1, 0, 4)], true, clRock);
createObjectGroupsDeprecated(group, 0,
avoidClasses(clWater, 3, clForest, 1, clPlayer, 20, clRock, 10, clHill, 1),
scaleByMapSize(4,16), 100
@ -419,19 +423,14 @@ createObjectGroupsDeprecated(group, 0,
RMS.SetProgress(85);
log("Creating straggler trees...");
var types = [oBaobab, oBaobab, oBaobab, oFig]; // some variation
var types = [oBaobab, oBaobab, oBaobab, oFig];
var num = floor(numStragglers / types.length);
for (var i = 0; i < types.length; ++i)
{
group = new SimpleGroup(
[new SimpleObject(types[i], 1,1, 0,3)],
true, clForest
);
createObjectGroupsDeprecated(group, 0,
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
);
}
num);
var planetm = 4;
log("Creating small grass tufts...");

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

@ -362,15 +362,14 @@ createFood
RMS.SetProgress(85);
log("Planting reeds...");
var types = [aReeds]; // some variation
for (var i = 0; i < types.length; ++i)
{
var group = new SimpleGroup([new SimpleObject(types[i], 1,1, 0,0)], true);
createObjectGroupsDeprecated(group, 0,
var types = [aReeds];
for (let type of types)
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(type, 1, 1, 0, 0)], true),
0,
borderClasses(clWater, 0, 6),
scaleByMapSize(960, 2000), 1000
);
}
scaleByMapSize(1, 2) * 1000,
1000);
RMS.SetProgress(90);

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

@ -1611,28 +1611,19 @@ log("Creating forests...");
var types = [
[[tForestFloor2, tMainTerrain, pForest1], [tForestFloor2, pForest1]],
[[tForestFloor1, tMainTerrain, pForest2], [tForestFloor1, pForest2]]
]; // some variation
if (currentBiome() == "savanna")
var size = numForest / (0.5 * scaleByMapSize(2,8) * numPlayers);
else
var size = numForest / (scaleByMapSize(2,8) * numPlayers);
];
var size = numForest / scaleByMapSize(2, 8) * numPlayers * (currentBiome() == "savanna" ? 2 : 1);
var num = floor(size / types.length);
for (var i = 0; i < types.length; ++i)
{
placer = new ClumpPlacer(numForest / num, 0.1, 0.1, 1);
painter = new LayeredPainter(
types[i], // terrains
[2] // widths
);
for (let type of types)
createAreas(
placer,
[painter, paintClass(clForest)],
new ClumpPlacer(numForest / num, 0.1, 0.1, 1),
[
new LayeredPainter(type, [2]),
paintClass(clForest)
],
[avoidClasses(clPlayer, 6, clForest, 10, clHill, 0), stayClasses(clLand, 4)],
num
);
}
num);
RMS.SetProgress(55);
log("Creating stone mines...");
@ -1658,35 +1649,23 @@ createObjectGroupsDeprecated(group, 0,
RMS.SetProgress(65);
log("Creating dirt patches...");
var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
for (var i = 0; i < sizes.length; i++)
{
placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
painter = new LayeredPainter(
[[tMainTerrain,tTier1Terrain],[tTier1Terrain,tTier2Terrain], [tTier2Terrain,tTier3Terrain]], // terrains
[1,1] // widths
);
for (let size of [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)])
createAreas(
placer,
[painter, paintClass(clDirt)],
new ClumpPlacer(size, 0.3, 0.06, 0.5),
[
new LayeredPainter([[tMainTerrain, tTier1Terrain],[tTier1Terrain, tTier2Terrain], [tTier2Terrain, tTier3Terrain]], [1, 1]),
paintClass(clDirt)
],
[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12), stayClasses(clLand, 5)],
scaleByMapSize(15, 45)
);
}
scaleByMapSize(15, 45));
log("Creating grass patches...");
var sizes = [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)];
for (var i = 0; i < sizes.length; i++)
{
placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
painter = new TerrainPainter(tTier4Terrain);
for (let size of [scaleByMapSize(2, 32), scaleByMapSize(3, 48), scaleByMapSize(5, 80)])
createAreas(
placer,
painter,
new ClumpPlacer(size, 0.3, 0.06, 0.5),
new TerrainPainter(tTier4Terrain),
[avoidClasses(clForest, 0, clHill, 0, clDirt, 5, clPlayer, 12), stayClasses(clLand, 5)],
scaleByMapSize(15, 45)
);
}
scaleByMapSize(15, 45));
log("Creating small decorative rocks...");
group = new SimpleGroup(
@ -1746,19 +1725,14 @@ createObjectGroupsDeprecated(group, 0,
RMS.SetProgress(85);
log("Creating straggler trees...");
var types = [oTree1, oTree2, oTree4, oTree3]; // some variation
var types = [oTree1, oTree2, oTree4, oTree3];
var num = floor(numStragglers / types.length);
for (var i = 0; i < types.length; ++i)
{
group = new SimpleGroup(
[new SimpleObject(types[i], 1,1, 0,3)],
true, clForest
);
createObjectGroupsDeprecated(group, 0,
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
);
}
num);
var planetm = 1;
if (currentBiome() == "tropic")

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

@ -68,6 +68,7 @@ createArea(
paintClass(clLand)
],
null);
RMS.SetProgress(10);
var [playerIDs, playerX, playerZ, playerAngle, startAngle] = radialPlayerPlacement(0.3);
@ -146,6 +147,7 @@ for (let i = 0; i < numPlayers; ++i)
addToClass(floor(femaleLocation[0]), floor(femaleLocation[1]), clWomen);
}
}
RMS.SetProgress(20);
paintTerrainBasedOnHeight(3.12, 29, 1, tCliff);
paintTileClassBasedOnHeight(3.12, 29, 1, clHill);
@ -157,6 +159,7 @@ for (let triggerPointTreasure of triggerPointTreasures)
[avoidClasses(clForest, 5, clPlayer, 5, clHill, 5), stayClasses(clLand, 5)],
scaleByMapSize(40, 140), 100
);
RMS.SetProgress(25);
createBumps(stayClasses(clLand, 5));
@ -166,6 +169,7 @@ createForests(
clForest,
1,
...rBiomeTreeCount(1));
RMS.SetProgress(30);
if (randBool())
createHills(
@ -179,6 +183,7 @@ else
[avoidClasses(clPlayer, 20, clHill, 5, clBaseResource, 3, clWomen, 5), stayClasses(clLand, 5)],
clHill,
scaleByMapSize(10, 60) * numPlayers);
RMS.SetProgress(40);
createHills(
[tCliff, tCliff, tHill],

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

@ -136,28 +136,22 @@ for (var i = 0; i < numPlayers; i++)
RMS.SetProgress(10);
log("Creating bumps...");
placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1);
painter = new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2);
createAreas(
placer,
painter,
new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1),
new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2),
avoidClasses(clPlayer, 13),
scaleByMapSize(300, 800)
);
scaleByMapSize(300, 800));
log("Creating hills...");
placer = new ChainPlacer(1, floor(scaleByMapSize(4, 6)), floor(scaleByMapSize(16, 40)), 0.5);
var terrainPainter = new LayeredPainter(
[tCliff, tHill], // terrains
[2] // widths
);
var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 22, 2);
createAreas(
placer,
[terrainPainter, elevationPainter, paintClass(clHill)],
new ChainPlacer(1, Math.floor(scaleByMapSize(4, 6)), Math.floor(scaleByMapSize(16, 40)), 0.5),
[
new LayeredPainter([tCliff, tHill], [2]),
new SmoothElevationPainter(ELEVATION_SET, 22, 2),
paintClass(clHill)
],
avoidClasses(clPlayer, 3, clGrass, 1, clHill, 10),
scaleByMapSize(1, 3) * numPlayers * 3
);
scaleByMapSize(1, 3) * numPlayers * 3);
RMS.SetProgress(25);
@ -174,64 +168,45 @@ log("Creating forests...");
var types = [
[[tMainDirt, tForestFloor2, pForestP], [tForestFloor2, pForestP]],
[[tMainDirt, tForestFloor1, pForestT], [tForestFloor1, pForestT]]
]; // some variation
];
var size = numForest / (scaleByMapSize(3,6) * numPlayers);
var num = floor(size / types.length);
for (var i = 0; i < types.length; ++i)
{
placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), numForest / (num * floor(scaleByMapSize(2,4))), 0.5);
painter = new LayeredPainter(
types[i], // terrains
[2] // widths
);
for (let type of types)
createAreas(
placer,
[painter, paintClass(clForest)],
new ChainPlacer(
1,
Math.floor(scaleByMapSize(3, 5)),
numForest / (num * Math.floor(scaleByMapSize(2, 4))),
0.5),
[
new LayeredPainter(type, [2]),
paintClass(clForest)
],
avoidClasses(clPlayer, 1, clGrass, 1, clForest, 10, clHill, 1),
num
);
}
num);
RMS.SetProgress(40);
log("Creating dirt patches...");
var sizes = [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)];
for (var i = 0; i < sizes.length; i++)
{
placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
painter = new LayeredPainter(
[tSecondaryDirt ,tDirt], // terrains
[1] // widths
);
for (let size of [scaleByMapSize(3, 6), scaleByMapSize(5, 10), scaleByMapSize(8, 21)])
createAreas(
placer,
painter,
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
new LayeredPainter([tSecondaryDirt, tDirt], [1]),
avoidClasses(clHill, 0, clForest, 0, clPlayer, 8, clGrass, 1),
scaleByMapSize(50, 90)
);
}
scaleByMapSize(50, 90));
RMS.SetProgress(60);
log("Creating big patches...");
var sizes = [scaleByMapSize(6, 30), scaleByMapSize(10, 50), scaleByMapSize(16, 70)];
for (var i = 0; i < sizes.length; i++)
{
placer = new ChainPlacer(1, floor(scaleByMapSize(3, 5)), sizes[i], 0.5);
painter = new LayeredPainter(
[tSecondaryDirt ,tDirt], // terrains
[1] // widths
);
for (let size of [scaleByMapSize(6, 30), scaleByMapSize(10, 50), scaleByMapSize(16, 70)])
createAreas(
placer,
painter,
new ChainPlacer(1, Math.floor(scaleByMapSize(3, 5)), size, 0.5),
new LayeredPainter([tSecondaryDirt, tDirt], [1]),
avoidClasses(clHill, 0, clForest, 0, clPlayer, 8, clGrass, 1),
scaleByMapSize(30, 90)
);
}
scaleByMapSize(30, 90));
RMS.SetProgress(70);
log("Creating stone mines...");
group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4), new RandomObject(aBushes, 2,4, 0,2)], true, clRock);
var group = new SimpleGroup([new SimpleObject(oStoneSmall, 0, 2, 0, 4), new SimpleObject(oStoneLarge, 1, 1, 0,4), new RandomObject(aBushes, 2, 4, 0, 2)], true, clRock);
createObjectGroupsDeprecated(group, 0,
[avoidClasses(clForest, 1, clPlayer, 10, clRock, 10, clHill, 1, clGrass, 1)],
scaleByMapSize(2,8), 100
@ -306,34 +281,24 @@ createObjectGroupsDeprecated(group, 0,
RMS.SetProgress(85);
log("Creating straggler trees...");
var types = [oPalm, oTamarix, oPine]; // some variation
var types = [oPalm, oTamarix, oPine];
var num = floor(numStragglers / types.length);
for (var i = 0; i < types.length; ++i)
{
group = new SimpleGroup(
[new SimpleObject(types[i], 1,1, 0,3)],
true, clForest
);
createObjectGroupsDeprecated(group, 0,
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
);
}
num);
log("Creating straggler trees...");
var types = [oPalm, oTamarix, oPine]; // some variation
var types = [oPalm, oTamarix, oPine];
var num = floor(numStragglers / types.length);
for (var i = 0; i < types.length; ++i)
{
group = new SimpleGroup(
[new SimpleObject(types[i], 1,1, 0,3)],
true, clForest
);
createObjectGroupsDeprecated(group, 0,
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
);
}
num);
setSkySet("sunny");
setSunElevation(PI / 8);

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

@ -217,51 +217,42 @@ paintRiver({
RMS.SetProgress(40);
log("Creating bumps...");
placer = new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1);
painter = new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2);
createAreas(
placer,
painter,
new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, 1),
new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2),
avoidClasses(clWater, 2, clPlayer, 6),
scaleByMapSize(100, 200)
);
scaleByMapSize(100, 200));
log("Creating ponds...");
var numLakes = round(scaleByMapSize(1,4) * numPlayers / 2);
placer = new ClumpPlacer(scaleByMapSize(100,250), 0.8, 0.1, 10);
var terrainPainter = new LayeredPainter(
[tShore, tShore, tShore], // terrains
[1,1] // widths
);
var elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -7, 4);
var numLakes = Math.round(scaleByMapSize(1, 4) * numPlayers / 2);
var waterAreas = createAreas(
placer,
[terrainPainter, elevationPainter, paintClass(clPond)],
new ClumpPlacer(scaleByMapSize(2, 5) * 50, 0.8, 0.1, 10),
[
new LayeredPainter([tShore, tShore, tShore], [1, 1]),
new SmoothElevationPainter(ELEVATION_SET, -7, 4),
paintClass(clPond)
],
avoidClasses(clPlayer, 25, clWater, 20, clPond, 10),
numLakes
);
log("Creating reeds...");
group = new SimpleGroup(
[new SimpleObject(aReeds, 1,3, 0,1)],
true
);
createObjectGroupsByAreasDeprecated(group, 0,
createObjectGroupsByAreasDeprecated(
new SimpleGroup([new SimpleObject(aReeds, 1, 3, 0, 1)], true),
0,
stayClasses(clPond, 1),
numLakes, 100,
waterAreas
);
numLakes,
100,
waterAreas);
log("Creating lillies...");
group = new SimpleGroup(
[new SimpleObject(aLillies, 1,3, 0,1)],
true
);
createObjectGroupsByAreasDeprecated(group, 0,
createObjectGroupsByAreasDeprecated(
new SimpleGroup([new SimpleObject(aLillies, 1, 3, 0, 1)], true),
0,
stayClasses(clPond, 1),
numLakes, 100,
waterAreas
);
numLakes,
100,
waterAreas);
waterAreas = [];
@ -276,54 +267,49 @@ var numStragglers = totalTrees * (1.0 - P_FOREST);
log("Creating forests...");
var num = scaleByMapSize(10,30);
placer = new ClumpPlacer(numForest / num, 0.15, 0.1, 0.5);
painter = new TerrainPainter([pForest, tForestFloor]);
createAreas(placer, [painter, paintClass(clForest)],
createAreas(
new ClumpPlacer(numForest / num, 0.15, 0.1, 0.5),
[
new TerrainPainter([pForest, tForestFloor]),
paintClass(clForest)
],
avoidClasses(clPlayer, 19, clForest, 4, clWater, 1, clDesert, 5, clPond, 2, clBaseResource, 3),
num, 50
);
num,
50);
RMS.SetProgress(50);
log("Creating grass patches...");
var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
for (var i = 0; i < sizes.length; i++)
{
placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
painter = new LayeredPainter(
[[tGrass,tGrassSand50],[tGrassSand50,tGrassSand25], [tGrassSand25,tGrass]], // terrains
[1,1] // widths
);
for (let size of [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)])
createAreas(
placer,
[painter, paintClass(clDirt)],
new ClumpPlacer(size, 0.3, 0.06, 0.5),
[
new LayeredPainter(
[[tGrass, tGrassSand50], [tGrassSand50, tGrassSand25], [tGrassSand25, tGrass]],
[1, 1]),
paintClass(clDirt)
],
avoidClasses(clForest, 0, clGrass, 5, clPlayer, 10, clWater, 1, clDirt, 5, clShore, 1, clPond, 1),
scaleByMapSize(15, 45)
);
}
scaleByMapSize(15, 45));
RMS.SetProgress(55);
log("Creating dirt patches...");
var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
for (var i = 0; i < sizes.length; i++)
{
placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
painter = new LayeredPainter(
[[tDirt,tDirtCracks],[tDirt,tFineSand], [tDirtCracks,tFineSand]], // terrains
[1,1] // widths
);
for (let size of [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)])
createAreas(
placer,
[painter, paintClass(clDirt)],
new ClumpPlacer(size, 0.3, 0.06, 0.5),
[
new LayeredPainter(
[[tDirt, tDirtCracks], [tDirt, tFineSand], [tDirtCracks, tFineSand]],
[1, 1]),
paintClass(clDirt)
],
avoidClasses(clForest, 0, clDirt, 5, clPlayer, 10, clWater, 1, clGrass, 5, clShore, 1, clPond, 1),
scaleByMapSize(15, 45)
);
}
scaleByMapSize(15, 45));
RMS.SetProgress(60);
log("Creating stone mines...");
group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
var group = new SimpleGroup([new SimpleObject(oStoneSmall, 0, 2, 0, 4), new SimpleObject(oStoneLarge, 1, 1, 0, 4)], true, clRock);
createObjectGroupsDeprecated(group, 0,
avoidClasses(clForest, 1, clPlayer, 20, clRock, 10, clWater, 1, clPond, 1),
scaleByMapSize(4,16), 100
@ -426,39 +412,33 @@ createObjectGroupsDeprecated(group, 0,
RMS.SetProgress(90);
log("Creating straggler trees...");
var types = [oDatePalm, oSDatePalm]; // some variation
var types = [oDatePalm, oSDatePalm];
var num = floor(0.5 * numStragglers / types.length);
for (var i = 0; i < types.length; ++i)
{
group = new SimpleGroup([new SimpleObject(types[i], 1,1, 0,0)], true);
createObjectGroupsDeprecated(group, 0,
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
);
}
num);
var types = [oDatePalm, oSDatePalm]; // some variation
var types = [oDatePalm, oSDatePalm];
var num = floor(0.1 * numStragglers / types.length);
for (var i = 0; i < types.length; ++i)
{
group = new SimpleGroup([new SimpleObject(types[i], 1,1, 0,0)], true);
createObjectGroupsDeprecated(group, 0,
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
);
}
num);
log("Creating straggler trees...");
var types = [oDatePalm, oSDatePalm]; // some variation
var types = [oDatePalm, oSDatePalm];
var num = floor(numStragglers / types.length);
for (var i = 0; i < types.length; ++i)
{
group = new SimpleGroup([new SimpleObject(types[i], 1,1, 0,0)], true);
createObjectGroupsDeprecated(group, 0,
for (let type of types)
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(type, 1, 1, 0, 0)], true),
0,
borderClasses(clPond, 1, 4),
num
);
}
num);
log("Creating obelisks");
group = new SimpleGroup(

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

@ -132,77 +132,55 @@ log("Creating forests...");
var types = [
[[tGrassB, tGrassA, pForestD], [tGrassB, pForestD]],
[[tGrassB, tGrassA, pForestP], [tGrassB, pForestP]]
]; // some variation
];
var size = numForest / (scaleByMapSize(2,8) * numPlayers);
var num = floor(size / types.length);
for (var i = 0; i < types.length; ++i)
{
placer = new ClumpPlacer(numForest / num, 0.1, 0.1, 1);
painter = new LayeredPainter(
types[i], // terrains
[2] // widths
);
for (let type of types)
createAreas(
placer,
[painter, paintClass(clForest)],
avoidClasses(clPlayer, 12, clForest, 10, clHill, 0),
num
);
}
new ClumpPlacer(numForest / num, 0.1, 0.1, 1),
[
new LayeredPainter(type, [2]),
paintClass(clForest)
],
avoidClasses(clPlayer, 12, clForest, 10, clHill, 0, clBaseResource, 6),
num);
RMS.SetProgress(70);
log("Creating dirt patches...");
var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
for (var i = 0; i < sizes.length; i++)
{
placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
painter = new LayeredPainter(
[tGrassA,tGrassA], // terrains
[1] // widths
);
for (let size of [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)])
createAreas(
placer,
[painter, paintClass(clDirt)],
new ClumpPlacer(size, 0.3, 0.06, 0.5),
[
new LayeredPainter([tGrassA, tGrassA], [1]),
paintClass(clDirt)
],
avoidClasses(clForest, 0, clHill, 0, clPlayer, 12),
scaleByMapSize(20, 80));
for (let size of [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)])
createAreas(
new ClumpPlacer(size, 0.3, 0.06, 0.5),
[
new LayeredPainter([tGrassB, tGrassB], [1]),
paintClass(clDirt)
],
avoidClasses(clForest, 0, clHill, 0, clPlayer, 12),
scaleByMapSize(20, 80));
for (let size of [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)])
createAreas(
new ClumpPlacer(size, 0.3, 0.06, 0.5),
[
new LayeredPainter([tGrassC, tGrassC], [1]),
paintClass(clDirt)
],
avoidClasses(clForest, 0, clHill, 0, clPlayer, 12),
scaleByMapSize(20, 80)
);
}
var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
for (var i = 0; i < sizes.length; i++)
{
placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
painter = new LayeredPainter(
[tGrassB,tGrassB], // terrains
[1] // widths
);
createAreas(
placer,
[painter, paintClass(clDirt)],
avoidClasses(clForest, 0, clHill, 0, clPlayer, 12),
scaleByMapSize(20, 80)
);
}
var sizes = [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)];
for (var i = 0; i < sizes.length; i++)
{
placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0.5);
painter = new LayeredPainter(
[tGrassC,tGrassC], // terrains
[1] // widths
);
createAreas(
placer,
[painter, paintClass(clDirt)],
avoidClasses(clForest, 0, clHill, 0, clPlayer, 12),
scaleByMapSize(20, 80)
);
}
log("Creating stone mines...");
group = new SimpleGroup([new SimpleObject(oStoneSmall, 0,2, 0,4), new SimpleObject(oStoneLarge, 1,1, 0,4)], true, clRock);
var group = new SimpleGroup([new SimpleObject(oStoneSmall, 0, 2, 0, 4), new SimpleObject(oStoneLarge, 1, 1, 0, 4)], true, clRock);
createObjectGroupsDeprecated(group, 0,
avoidClasses(clForest, 1, clPlayer, 10, clRock, 10, clHill, 1),
scaleByMapSize(4,16), 100
@ -249,18 +227,13 @@ createObjectGroupsDeprecated(
RMS.SetProgress(95);
log("Creating straggler trees...");
var types = [oTree]; // some variation
var types = [oTree];
var num = floor(numStragglers / types.length);
for (var i = 0; i < types.length; ++i)
{
group = new SimpleGroup(
[new SimpleObject(types[i], 1,1, 0,3)],
true, clForest
);
createObjectGroupsDeprecated(group, 0,
avoidClasses(clForest, 1, clHill, 1, clPlayer, 12, clMetal, 6, clRock, 6),
num
);
}
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);
ExportMap();