Index: ps/trunk/binaries/data/mods/public/maps/random/rmgen-common/player.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/rmgen-common/player.js (revision 25764)
+++ ps/trunk/binaries/data/mods/public/maps/random/rmgen-common/player.js (revision 25765)
@@ -1,843 +1,845 @@
/**
* @file These functions locate and place the starting entities of players.
*/
var g_NomadTreasureTemplates = {
"food": "gaia/treasure/food_jars",
"wood": "gaia/treasure/wood",
"stone": "gaia/treasure/stone",
"metal": "gaia/treasure/metal"
};
/**
* These are identifiers of functions that can generate parts of a player base.
* There must be a function starting with placePlayerBase and ending with this name.
* This is a global so mods can extend this from external files.
*/
var g_PlayerBaseFunctions = [
// Possibly mark player class first here and use it afterwards
"CityPatch",
// Create the largest and most important entities first
"Trees",
"Mines",
"Treasures",
"Berries",
"Chicken",
"Decoratives"
];
function isNomad()
{
return !!g_MapSettings.Nomad;
}
function getNumPlayers()
{
return g_MapSettings.PlayerData.length - 1;
}
function getCivCode(playerID)
{
return g_MapSettings.PlayerData[playerID].Civ;
}
function areAllies(playerID1, playerID2)
{
return g_MapSettings.PlayerData[playerID1].Team !== undefined &&
g_MapSettings.PlayerData[playerID2].Team !== undefined &&
g_MapSettings.PlayerData[playerID1].Team != -1 &&
g_MapSettings.PlayerData[playerID2].Team != -1 &&
g_MapSettings.PlayerData[playerID1].Team === g_MapSettings.PlayerData[playerID2].Team;
}
function getPlayerTeam(playerID)
{
if (g_MapSettings.PlayerData[playerID].Team === undefined)
return -1;
return g_MapSettings.PlayerData[playerID].Team;
}
/**
* Gets the default starting entities for the civ of the given player, as defined by the civ file.
*/
function getStartingEntities(playerID)
{
return g_CivData[getCivCode(playerID)].StartEntities;
}
/**
* Places the given entities at the given location (typically a civic center and starting units).
* @param location - A Vector2D specifying tile coordinates.
* @param civEntities - An array of objects with the Template property and optionally a Count property.
* The first entity is placed in the center, the other ones surround it.
*/
function placeStartingEntities(location, playerID, civEntities, dist = 6, orientation = BUILDING_ORIENTATION)
{
// Place the central structure
let i = 0;
let firstTemplate = civEntities[i].Template;
if (firstTemplate.startsWith("structures/"))
{
g_Map.placeEntityPassable(firstTemplate, playerID, location, orientation);
++i;
}
// Place entities surrounding it
let space = 2;
for (let j = i; j < civEntities.length; ++j)
{
let angle = orientation - Math.PI * (1 - j / 2);
let count = civEntities[j].Count || 1;
for (let num = 0; num < count; ++num)
{
let position = Vector2D.sum([
location,
new Vector2D(dist, 0).rotate(-angle),
new Vector2D(space * (-num + (count - 1) / 2), 0).rotate(angle)
]);
g_Map.placeEntityPassable(civEntities[j].Template, playerID, position, angle);
}
}
}
/**
* Places the default starting entities as defined by the civilization definition, optionally including city walls.
*/
function placeCivDefaultStartingEntities(position, playerID, wallType, dist = 6, orientation = BUILDING_ORIENTATION)
{
placeStartingEntities(position, playerID, getStartingEntities(playerID), dist, orientation);
placeStartingWalls(position, playerID, wallType, orientation);
}
/**
* If the map is large enough and the civilization defines them, places the initial city walls or towers.
* @param {string|boolean} wallType - Either "towers" to only place the wall turrets or a boolean indicating enclosing city walls.
*/
function placeStartingWalls(position, playerID, wallType, orientation = BUILDING_ORIENTATION)
{
let civ = getCivCode(playerID);
if (civ != "iber" || g_Map.getSize() <= 128)
return;
// TODO: should prevent trees inside walls
// When fixing, remove the DeleteUponConstruction flag from template_gaia_flora.xml
if (wallType == "towers")
placePolygonalWall(position, 15, ["entry"], "tower", civ, playerID, orientation, 7);
else if (wallType)
placeGenericFortress(position, 20, playerID);
}
/**
* Places the civic center and starting resources for all given players.
*/
function placePlayerBases(playerBaseArgs)
{
g_Map.log("Creating playerbases");
let [playerIDs, playerPosition] = playerBaseArgs.PlayerPlacement;
for (let i = 0; i < getNumPlayers(); ++i)
{
playerBaseArgs.playerID = playerIDs[i];
playerBaseArgs.playerPosition = playerPosition[i];
placePlayerBase(playerBaseArgs);
}
}
/**
* Places the civic center and starting resources.
*/
function placePlayerBase(playerBaseArgs)
{
if (isNomad())
return;
placeCivDefaultStartingEntities(playerBaseArgs.playerPosition, playerBaseArgs.playerID, playerBaseArgs.Walls !== undefined ? playerBaseArgs.Walls : true);
if (playerBaseArgs.PlayerTileClass)
addCivicCenterAreaToClass(playerBaseArgs.playerPosition, playerBaseArgs.PlayerTileClass);
for (let functionID of g_PlayerBaseFunctions)
{
let funcName = "placePlayerBase" + functionID;
let func = global[funcName];
if (!func)
throw new Error("Could not find " + funcName);
if (!playerBaseArgs[functionID])
continue;
let args = playerBaseArgs[functionID];
// Copy some global arguments to the arguments for each function
for (let prop of ["playerID", "playerPosition", "BaseResourceClass", "baseResourceConstraint"])
args[prop] = playerBaseArgs[prop];
func(args);
}
}
function defaultPlayerBaseRadius()
{
return scaleByMapSize(15, 25);
}
/**
* Marks the corner and center tiles of an area that is about the size of a Civic Center with the given TileClass.
* Used to prevent resource collisions with the Civic Center.
*/
function addCivicCenterAreaToClass(position, tileClass)
{
createArea(
new DiskPlacer(5, position),
new TileClassPainter(tileClass));
}
/**
* Helper function.
*/
function getPlayerBaseArgs(playerBaseArgs)
{
let baseResourceConstraint = playerBaseArgs.BaseResourceClass && avoidClasses(playerBaseArgs.BaseResourceClass, 4);
if (playerBaseArgs.baseResourceConstraint)
baseResourceConstraint = new AndConstraint([baseResourceConstraint, playerBaseArgs.baseResourceConstraint]);
return [
(property, defaultVal) => playerBaseArgs[property] === undefined ? defaultVal : playerBaseArgs[property],
playerBaseArgs.playerPosition,
baseResourceConstraint
];
}
function placePlayerBaseCityPatch(args)
{
let [get, basePosition, baseResourceConstraint] = getPlayerBaseArgs(args);
let painters = [];
if (args.outerTerrain && args.innerTerrain)
painters.push(new LayeredPainter([args.outerTerrain, args.innerTerrain], [get("width", 1)]));
if (args.painters)
painters = painters.concat(args.painters);
createArea(
new ClumpPlacer(
Math.floor(diskArea(get("radius", defaultPlayerBaseRadius() / 3))),
get("coherence", 0.6),
get("smoothness", 0.3),
get("failFraction", Infinity),
basePosition),
painters);
}
function placePlayerBaseChicken(args)
{
let [get, basePosition, baseResourceConstraint] = getPlayerBaseArgs(args);
for (let i = 0; i < get("groupCount", 2); ++i)
{
let success = false;
for (let tries = 0; tries < get("maxTries", 30); ++tries)
{
let position = new Vector2D(0, get("distance", 9)).rotate(randomAngle()).add(basePosition);
if (createObjectGroup(
new SimpleGroup(
[
new SimpleObject(
get("template", "gaia/fauna_chicken"),
get("minGroupCount", 5),
get("maxGroupCount", 5),
get("minGroupDistance", 0),
get("maxGroupDistance", 2))
],
true,
args.BaseResourceClass,
position),
0,
baseResourceConstraint))
{
success = true;
break;
}
}
if (!success)
{
error("Could not place chicken for player " + args.playerID);
return;
}
}
}
function placePlayerBaseBerries(args)
{
let [get, basePosition, baseResourceConstraint] = getPlayerBaseArgs(args);
for (let tries = 0; tries < get("maxTries", 30); ++tries)
{
let position = new Vector2D(0, get("distance", 12)).rotate(randomAngle()).add(basePosition);
if (createObjectGroup(
new SimpleGroup(
[new SimpleObject(args.template, get("minCount", 5), get("maxCount", 5), get("maxDist", 1), get("maxDist", 3))],
true,
args.BaseResourceClass,
position),
0,
baseResourceConstraint))
return;
}
error("Could not place berries for player " + args.playerID);
}
function placePlayerBaseMines(args)
{
let [get, basePosition, baseResourceConstraint] = getPlayerBaseArgs(args);
let angleBetweenMines = randFloat(get("minAngle", Math.PI / 6), get("maxAngle", Math.PI / 3));
let mineCount = args.types.length;
let groupElements = [];
if (args.groupElements)
groupElements = groupElements.concat(args.groupElements);
for (let tries = 0; tries < get("maxTries", 75); ++tries)
{
// First find a place where all mines can be placed
let pos = [];
let startAngle = randomAngle();
for (let i = 0; i < mineCount; ++i)
{
let angle = startAngle + angleBetweenMines * (i + (mineCount - 1) / 2);
pos[i] = new Vector2D(0, get("distance", 12)).rotate(angle).add(basePosition).round();
if (!g_Map.validTilePassable(pos[i]) || !baseResourceConstraint.allows(pos[i]))
{
pos = undefined;
break;
}
}
if (!pos)
continue;
// Place the mines
for (let i = 0; i < mineCount; ++i)
{
if (args.types[i].type && args.types[i].type == "stone_formation")
{
createStoneMineFormation(pos[i], args.types[i].template, args.types[i].terrain);
args.BaseResourceClass.add(pos[i]);
continue;
}
createObjectGroup(
new SimpleGroup(
[new SimpleObject(args.types[i].template, 1, 1, 0, 0)].concat(groupElements),
true,
args.BaseResourceClass,
pos[i]),
0);
}
return;
}
error("Could not place mines for player " + args.playerID);
}
function placePlayerBaseTrees(args)
{
let [get, basePosition, baseResourceConstraint] = getPlayerBaseArgs(args);
let num = Math.floor(get("count", scaleByMapSize(7, 20)));
for (let x = 0; x < get("maxTries", 30); ++x)
{
let position = new Vector2D(0, randFloat(get("minDist", 11), get("maxDist", 13))).rotate(randomAngle()).add(basePosition).round();
if (createObjectGroup(
new SimpleGroup(
[new SimpleObject(args.template, num, num, get("minDistGroup", 0), get("maxDistGroup", 5))],
false,
args.BaseResourceClass,
position),
0,
baseResourceConstraint))
return;
}
error("Could not place starting trees for player " + args.playerID);
}
function placePlayerBaseTreasures(args)
{
let [get, basePosition, baseResourceConstraint] = getPlayerBaseArgs(args);
for (let resourceTypeArgs of args.types)
{
get = (property, defaultVal) => resourceTypeArgs[property] === undefined ? defaultVal : resourceTypeArgs[property];
let success = false;
for (let tries = 0; tries < get("maxTries", 30); ++tries)
{
let position = new Vector2D(0, randFloat(get("minDist", 11), get("maxDist", 13))).rotate(randomAngle()).add(basePosition).round();
if (createObjectGroup(
new SimpleGroup(
[new SimpleObject(resourceTypeArgs.template, get("count", 14), get("count", 14), get("minDistGroup", 1), get("maxDistGroup", 3))],
false,
args.BaseResourceClass,
position),
0,
baseResourceConstraint))
{
success = true;
break;
}
}
if (!success)
{
error("Could not place treasure " + resourceTypeArgs.template + " for player " + args.playerID);
return;
}
}
}
/**
* Typically used for placing grass tufts around the civic centers.
*/
function placePlayerBaseDecoratives(args)
{
let [get, basePosition, baseResourceConstraint] = getPlayerBaseArgs(args);
for (let i = 0; i < get("count", scaleByMapSize(2, 5)); ++i)
{
let success = false;
for (let x = 0; x < get("maxTries", 30); ++x)
{
let position = new Vector2D(0, randIntInclusive(get("minDist", 8), get("maxDist", 11))).rotate(randomAngle()).add(basePosition).round();
if (createObjectGroup(
new SimpleGroup(
[new SimpleObject(args.template, get("minCount", 2), get("maxCount", 5), 0, 1)],
false,
args.BaseResourceClass,
position),
0,
baseResourceConstraint))
{
success = true;
break;
}
}
if (!success)
// Don't warn since the decoratives are not important
return;
}
}
function placePlayersNomad(playerClass, constraints)
{
if (!isNomad())
return undefined;
g_Map.log("Placing nomad starting units");
let distance = scaleByMapSize(60, 240);
let constraint = new StaticConstraint(constraints);
let numPlayers = getNumPlayers();
let playerIDs = shuffleArray(sortAllPlayers());
let playerPosition = [];
for (let i = 0; i < numPlayers; ++i)
{
let objects = getStartingEntities(playerIDs[i]).filter(ents => ents.Template.startsWith("units/")).map(
ents => new SimpleObject(ents.Template, ents.Count || 1, ents.Count || 1, 1, 3));
// Add treasure if too few resources for a civic center
let ccCost = Engine.GetTemplate("structures/" + getCivCode(playerIDs[i]) + "/civil_centre").Cost.Resources;
for (let resourceType in ccCost)
{
let treasureTemplate = g_NomadTreasureTemplates[resourceType];
let count = Math.max(0, Math.ceil(
(ccCost[resourceType] - (g_MapSettings.StartingResources || 0)) /
Engine.GetTemplate(treasureTemplate).Treasure.Resources[resourceType]));
objects.push(new SimpleObject(treasureTemplate, count, count, 3, 5));
}
// Try place these entities at a random location
let group = new SimpleGroup(objects, true, playerClass);
let success = false;
for (let distanceFactor of [1, 1/2, 1/4, 0])
if (createObjectGroups(group, playerIDs[i], new AndConstraint([constraint, avoidClasses(playerClass, distance * distanceFactor)]), 1, 200, false).length)
{
success = true;
playerPosition[i] = group.centerPosition;
break;
}
if (!success)
throw new Error("Could not place starting units for player " + playerIDs[i] + "!");
}
return [playerIDs, playerPosition];
}
/**
* Sorts an array of player IDs by team index. Players without teams come first.
* Randomize order for players of the same team.
*/
function sortPlayers(playerIDs)
{
return shuffleArray(playerIDs).sort((playerID1, playerID2) => getPlayerTeam(playerID1) - getPlayerTeam(playerID2));
}
/**
* Randomize playerIDs but sort by team.
*
* @returns {Array} - every item is an array of player indices
*/
function sortAllPlayers()
{
let playerIDs = [];
for (let i = 0; i < getNumPlayers(); ++i)
playerIDs.push(i+1);
return sortPlayers(playerIDs);
}
/**
* Rearrange order so that teams of neighboring players alternate (if the given IDs are sorted by team).
*/
function primeSortPlayers(playerIDs)
{
let prime = [];
for (let i = 0; i < Math.floor(playerIDs.length / 2); ++i)
{
prime.push(playerIDs[i]);
prime.push(playerIDs[playerIDs.length - 1 - i]);
}
if (playerIDs.length % 2)
prime.push(playerIDs[Math.floor(playerIDs.length / 2)]);
return prime;
}
function primeSortAllPlayers()
{
return primeSortPlayers(sortAllPlayers());
}
/*
* Separates playerIDs into two arrays such that teammates are in the same array,
* unless everyone's on the same team in which case they'll be split in half.
*/
function partitionPlayers(playerIDs)
{
let teamIDs = Array.from(new Set(playerIDs.map(getPlayerTeam)));
let teams = teamIDs.map(teamID => playerIDs.filter(playerID => getPlayerTeam(playerID) == teamID));
if (teamIDs.indexOf(-1) != -1)
teams = teams.concat(teams.splice(teamIDs.indexOf(-1), 1)[0].map(playerID => [playerID]));
if (teams.length == 1)
{
let idx = Math.floor(teams[0].length / 2);
teams = [teams[0].slice(idx), teams[0].slice(0, idx)];
}
teams.sort((a, b) => b.length - a.length);
// Use the greedy algorithm: add the next team to the side with fewer players
return teams.reduce(([east, west], team) =>
east.length > west.length ?
[east, west.concat(team)] :
[east.concat(team), west],
[[], []]);
}
/**
* Determine player starting positions on a circular pattern.
*/
function playerPlacementCircle(radius, startingAngle = undefined, center = undefined)
{
let startAngle = startingAngle !== undefined ? startingAngle : randomAngle();
let [playerPosition, playerAngle] = distributePointsOnCircle(getNumPlayers(), startAngle, radius, center || g_Map.getCenter());
return [sortAllPlayers(), playerPosition.map(p => p.round()), playerAngle, startAngle];
}
/**
* Determine player starting positions on a circular pattern, with a custom angle for each player.
* Commonly used for gulf terrains.
*/
function playerPlacementCustomAngle(radius, center, playerAngleFunc)
{
let playerPosition = [];
let playerAngle = [];
let numPlayers = getNumPlayers();
for (let i = 0; i < numPlayers; ++i)
{
playerAngle[i] = playerAngleFunc(i);
playerPosition[i] = Vector2D.add(center, new Vector2D(radius, 0).rotate(-playerAngle[i])).round();
}
return [playerPosition, playerAngle];
}
/**
* Returns player starting positions equally spaced along an arc.
*/
function playerPlacementArc(playerIDs, center, radius, startAngle, endAngle)
{
return distributePointsOnCircularSegment(
playerIDs.length + 2,
endAngle - startAngle,
startAngle,
radius,
center
)[0].slice(1, -1).map(p => p.round());
}
/**
* Returns player starting positions located on two symmetrically placed arcs, with teammates placed on the same arc.
*/
function playerPlacementArcs(playerIDs, center, radius, mapAngle, startAngle, endAngle)
{
let [east, west] = partitionPlayers(playerIDs);
let eastPosition = playerPlacementArc(east, center, radius, mapAngle + startAngle, mapAngle + endAngle);
let westPosition = playerPlacementArc(west, center, radius, mapAngle - startAngle, mapAngle - endAngle);
return playerIDs.map(playerID => east.indexOf(playerID) != -1 ?
eastPosition[east.indexOf(playerID)] :
westPosition[west.indexOf(playerID)]);
}
/**
* Returns player starting positions located on two parallel lines, typically used by central river maps.
* If there are two teams with an equal number of players, each team will occupy exactly one line.
* Angle 0 means the players are placed in north to south direction, i.e. along the Z axis.
*/
function playerPlacementRiver(angle, width, center = undefined)
{
let numPlayers = getNumPlayers();
let numPlayersEven = numPlayers % 2 == 0;
let mapSize = g_Map.getSize();
let centerPosition = center || g_Map.getCenter();
let playerPosition = [];
for (let i = 0; i < numPlayers; ++i)
{
let currentPlayerEven = i % 2 == 0;
let offsetDivident = numPlayersEven || currentPlayerEven ? (i + 1) % 2 : 0;
let offsetDivisor = numPlayersEven ? 0 : currentPlayerEven ? +1 : -1;
playerPosition[i] = new Vector2D(
width * (i % 2) + (mapSize - width) / 2,
fractionToTiles(((i - 1 + offsetDivident) / 2 + 1) / ((numPlayers + offsetDivisor) / 2 + 1))
).rotateAround(angle, centerPosition).round();
}
return [primeSortAllPlayers(), playerPosition];
}
/**
* Returns starting positions located on two parallel lines.
* The locations on the first line are shifted in comparison to the other line.
*/
function playerPlacementLine(angle, center, width)
{
let playerPosition = [];
let numPlayers = getNumPlayers();
for (let i = 0; i < numPlayers; ++i)
playerPosition[i] = Vector2D.add(
center,
new Vector2D(
fractionToTiles((i + 1) / (numPlayers + 1) - 0.5),
width * (i % 2 - 1/2)
).rotate(angle)
).round();
return playerPosition;
}
/**
* Returns a random location for each player that meets the given constraints and
* orders the playerIDs so that players become grouped by team.
*/
function playerPlacementRandom(playerIDs, constraints = undefined)
{
let locations = [];
let attempts = 0;
let resets = 0;
let mapCenter = g_Map.getCenter();
let playerMinDistSquared = Math.square(fractionToTiles(0.25));
let borderDistance = fractionToTiles(0.08);
let area = createArea(new MapBoundsPlacer(), undefined, new AndConstraint(constraints));
for (let i = 0; i < getNumPlayers(); ++i)
{
- let position = pickRandom(area.getPoints());
+ const position = pickRandom(area.getPoints());
+ if (!position)
+ return undefined;
// Minimum distance between initial bases must be a quarter of the map diameter
if (locations.some(loc => loc.distanceToSquared(position) < playerMinDistSquared) ||
position.distanceToSquared(mapCenter) > Math.square(mapCenter.x - borderDistance))
{
--i;
++attempts;
// Reset if we're in what looks like an infinite loop
if (attempts > 500)
{
locations = [];
i = -1;
attempts = 0;
++resets;
// Reduce minimum player distance progressively
if (resets % 25 == 0)
playerMinDistSquared *= 0.95;
// If we only pick bad locations, stop trying to place randomly
if (resets == 500)
return undefined;
}
continue;
}
locations[i] = position;
}
return groupPlayersByArea(playerIDs, locations);
}
/**
* Pick locations from the given set so that teams end up grouped.
*/
function groupPlayersByArea(playerIDs, locations)
{
playerIDs = sortPlayers(playerIDs);
let minDist = Infinity;
let minLocations;
// Of all permutations of starting locations, find the one where
// the sum of the distances between allies is minimal, weighted by teamsize.
heapsPermute(shuffleArray(locations).slice(0, playerIDs.length), v => v.clone(), permutation => {
let dist = 0;
let teamDist = 0;
let teamSize = 0;
for (let i = 1; i < playerIDs.length; ++i)
{
let team1 = getPlayerTeam(playerIDs[i - 1]);
let team2 = getPlayerTeam(playerIDs[i]);
++teamSize;
if (team1 != -1 && team1 == team2)
teamDist += permutation[i - 1].distanceTo(permutation[i]);
else
{
dist += teamDist / teamSize;
teamDist = 0;
teamSize = 0;
}
}
if (teamSize)
dist += teamDist / teamSize;
if (dist < minDist)
{
minDist = dist;
minLocations = permutation;
}
});
return [playerIDs, minLocations];
}
/**
* Sorts the playerIDs so that team members are as close as possible on a ring.
*/
function groupPlayersCycle(startLocations)
{
let startLocationOrder = sortPointsShortestCycle(startLocations);
let newStartLocations = [];
for (let i = 0; i < startLocations.length; ++i)
newStartLocations.push(startLocations[startLocationOrder[i]]);
startLocations = newStartLocations;
// Sort players by team
let playerIDs = [];
let teams = [];
for (let i = 0; i < g_MapSettings.PlayerData.length - 1; ++i)
{
playerIDs.push(i+1);
let t = g_MapSettings.PlayerData[i + 1].Team;
if (teams.indexOf(t) == -1 && t !== undefined)
teams.push(t);
}
playerIDs = sortPlayers(playerIDs);
if (!teams.length)
return [playerIDs, startLocations];
// Minimize maximum distance between players within a team
let minDistance = Infinity;
let bestShift;
for (let s = 0; s < playerIDs.length; ++s)
{
let maxTeamDist = 0;
for (let pi = 0; pi < playerIDs.length - 1; ++pi)
{
let t1 = getPlayerTeam(playerIDs[(pi + s) % playerIDs.length]);
if (teams.indexOf(t1) === -1)
continue;
for (let pj = pi + 1; pj < playerIDs.length; ++pj)
{
if (t1 != getPlayerTeam(playerIDs[(pj + s) % playerIDs.length]))
continue;
maxTeamDist = Math.max(
maxTeamDist,
Math.euclidDistance2D(
startLocations[pi].x,
startLocations[pi].y,
startLocations[pj].x,
startLocations[pj].y));
}
}
if (maxTeamDist < minDistance)
{
minDistance = maxTeamDist;
bestShift = s;
}
}
if (bestShift)
{
let newPlayerIDs = [];
for (let i = 0; i < playerIDs.length; ++i)
newPlayerIDs.push(playerIDs[(i + bestShift) % playerIDs.length]);
playerIDs = newPlayerIDs;
}
return [playerIDs, startLocations];
}
Index: ps/trunk/binaries/data/mods/public/maps/random/unknown.js
===================================================================
--- ps/trunk/binaries/data/mods/public/maps/random/unknown.js (revision 25764)
+++ ps/trunk/binaries/data/mods/public/maps/random/unknown.js (revision 25765)
@@ -1,1076 +1,1077 @@
Engine.LoadLibrary("rmgen");
Engine.LoadLibrary("rmgen-common");
Engine.LoadLibrary("rmbiome");
TILE_CENTERED_HEIGHT_MAP = true;
setSelectedBiome();
const tMainTerrain = g_Terrains.mainTerrain;
const tForestFloor1 = g_Terrains.forestFloor1;
const tForestFloor2 = g_Terrains.forestFloor2;
const tCliff = g_Terrains.cliff;
const tTier1Terrain = g_Terrains.tier1Terrain;
const tTier2Terrain = g_Terrains.tier2Terrain;
const tTier3Terrain = g_Terrains.tier3Terrain;
const tHill = g_Terrains.hill;
const tRoad = g_Terrains.road;
const tRoadWild = g_Terrains.roadWild;
const tTier4Terrain = g_Terrains.tier4Terrain;
const tShore = g_Terrains.shore;
const tWater = g_Terrains.water;
const oTree1 = g_Gaia.tree1;
const oTree2 = g_Gaia.tree2;
const oTree4 = g_Gaia.tree4;
const oTree5 = g_Gaia.tree5;
const oFruitBush = g_Gaia.fruitBush;
const oMainHuntableAnimal = g_Gaia.mainHuntableAnimal;
const oSecondaryHuntableAnimal = g_Gaia.secondaryHuntableAnimal;
const oFish = g_Gaia.fish;
const oStoneLarge = g_Gaia.stoneLarge;
const oStoneSmall = g_Gaia.stoneSmall;
const oMetalLarge = g_Gaia.metalLarge;
const oWoodTreasure = "gaia/treasure/wood";
const aGrass = g_Decoratives.grass;
const aGrassShort = g_Decoratives.grassShort;
const aReeds = g_Decoratives.reeds;
const aLillies = g_Decoratives.lillies;
const aRockLarge = g_Decoratives.rockLarge;
const aRockMedium = g_Decoratives.rockMedium;
const aBushMedium = g_Decoratives.bushMedium;
const aBushSmall = g_Decoratives.bushSmall;
const pForest1 = [tForestFloor2 + TERRAIN_SEPARATOR + oTree1, tForestFloor2 + TERRAIN_SEPARATOR + oTree2, tForestFloor2];
const pForest2 = [tForestFloor1 + TERRAIN_SEPARATOR + oTree4, tForestFloor1 + TERRAIN_SEPARATOR + oTree5, tForestFloor1];
const heightSeaGround = -5;
const heightLand = 3;
const heightCliff = 3.12;
const heightHill = 18;
const heightOffsetBump = 2;
var g_Map = new RandomMap(heightSeaGround, tWater);
const numPlayers = getNumPlayers();
const mapSize = g_Map.getSize();
const mapCenter = g_Map.getCenter();
const mapBounds = g_Map.getBounds();
var clPlayer = g_Map.createTileClass();
var clPlayerTerritory = g_Map.createTileClass();
var clHill = g_Map.createTileClass();
var clForest = g_Map.createTileClass();
var clWater = g_Map.createTileClass();
var clDirt = g_Map.createTileClass();
var clRock = g_Map.createTileClass();
var clMetal = g_Map.createTileClass();
var clFood = g_Map.createTileClass();
var clPeninsulaSteam = g_Map.createTileClass();
var clBaseResource = g_Map.createTileClass();
var clLand = g_Map.createTileClass();
var clShallow = g_Map.createTileClass();
var landElevationPainter = new SmoothElevationPainter(ELEVATION_SET, heightLand, 4);
var unknownMapFunctions = {
"land": [
"Continent",
"Isthmus",
"CentralRiverLand",
"EdgeSeas",
"Gulf",
"Lakes",
"Passes",
"Lowlands",
"Mainland"
],
"naval": [
"CentralSea",
"CentralRiverNaval",
"Archipelago",
"RiversAndLake"
]
};
/**
* The player IDs and locations shall only be determined by the landscape functions if it's not a nomad game,
* because nomad maps randomize the locations after the terrain generation.
* The locations should only determined by the landscape functions to avoid placing bodies of water and resources into civic centers and the starting resources.
*/
var playerIDs = sortAllPlayers();
var playerPosition = [];
var g_StartingTreasures = false;
var g_StartingWalls = true;
function createUnknownMap()
{
- global["unknown" + g_MapSettings.Landscape || pickRandom([...unknownMapFunctions.land, ...unknownMapFunctions.naval])]();
+ const landscape = g_MapSettings.Landscape || pickRandom([...unknownMapFunctions.land, ...unknownMapFunctions.naval]);
+ global["unknown" + landscape]();
paintUnknownMapBasedOnHeight();
createUnknownPlayerBases();
createUnknownObjects();
placePlayersNomad(clPlayer, avoidClasses(clForest, 1, clMetal, 4, clRock, 4, clHill, 4, clFood, 2, clWater, 10));
}
/**
* Chain of islands or many disconnected islands.
*/
function unknownArchipelago()
{
g_StartingWalls = "towers";
g_StartingTreasures = true;
let [pIDs, islandPosition] = playerPlacementCircle(fractionToTiles(0.35));
if (!isNomad())
{
[playerIDs, playerPosition] = [pIDs, islandPosition];
markPlayerArea("large");
}
g_Map.log("Creating islands");
let islandSize = diskArea(scaleByMapSize(17, 29));
for (let i = 0; i < numPlayers; ++i)
createArea(
new ClumpPlacer(islandSize, 0.8, 0.1, Infinity, islandPosition[i]),
landElevationPainter);
let type = isNomad() ? randIntInclusive(1, 2) : randIntInclusive(1, 3);
if (type == 1)
{
g_Map.log("Creating archipelago");
createAreas(
new ClumpPlacer(islandSize * randFloat(0.8, 1.2), 0.8, 0.1, Infinity),
[
landElevationPainter,
new TileClassPainter(clLand)
],
null,
scaleByMapSize(2, 5) * randIntInclusive(8, 14));
g_Map.log("Creating shore jaggedness with small puddles");
createAreas(
new ClumpPlacer(scaleByMapSize(15, 80), 0.2, 0.1, Infinity),
[
new SmoothElevationPainter(ELEVATION_SET, heightLand, 4),
new TileClassPainter(clLand)
],
borderClasses(clLand, 6, 3),
scaleByMapSize(12, 130) * 2,
150);
}
else if (type == 2)
{
g_Map.log("Creating islands");
createAreas(
new ClumpPlacer(islandSize * randFloat(0.6, 1.4), 0.8, 0.1, randFloat(0.0, 0.2)),
[
landElevationPainter,
new TileClassPainter(clLand)
],
avoidClasses(clLand, 3, clPlayerTerritory, 3),
scaleByMapSize(6, 10) * randIntInclusive(8, 14));
g_Map.log("Creating small islands");
createAreas(
new ClumpPlacer(islandSize * randFloat(0.3, 0.7), 0.8, 0.1, 0.07),
[
new SmoothElevationPainter(ELEVATION_SET, heightLand, 6),
new TileClassPainter(clLand)
],
avoidClasses(clLand, 3, clPlayerTerritory, 3),
scaleByMapSize(2, 6) * randIntInclusive(6, 15),
25);
}
else if (type == 3)
{
g_Map.log("Creating tight islands");
createAreas(
new ClumpPlacer(islandSize * randFloat(0.8, 1.2), 0.8, 0.1, Infinity),
[
landElevationPainter,
new TileClassPainter(clLand)
],
avoidClasses(clLand, randIntInclusive(8, 16), clPlayerTerritory, 3),
scaleByMapSize(2, 5) * randIntInclusive(8, 14));
}
}
/**
* Disk shaped mainland with water on the edge.
*/
function unknownContinent()
{
let waterHeight = -5;
if (!isNomad())
{
g_Map.log("Ensuring player area");
[playerIDs, playerPosition] = playerPlacementCircle(fractionToTiles(0.25));
markPlayerArea("small");
for (let i = 0; i < numPlayers; ++i)
createArea(
new ChainPlacer(
2,
Math.floor(scaleByMapSize(5, 9)),
Math.floor(scaleByMapSize(5, 20)),
Infinity,
playerPosition[i],
0,
[Math.floor(scaleByMapSize(23, 50))]),
[
landElevationPainter,
new TileClassPainter(clLand)
]);
}
g_Map.log("Creating continent");
createArea(
new ClumpPlacer(diskArea(fractionToTiles(0.38)), 0.9, 0.09, Infinity, mapCenter),
[
landElevationPainter,
new TileClassPainter(clLand)
]);
if (randBool(1/3))
{
g_Map.log("Creating peninsula (i.e. half the map not being surrounded by water)");
let angle = randomAngle();
let peninsulaPosition1 = Vector2D.add(mapCenter, new Vector2D(fractionToTiles(0.25), 0).rotate(-angle));
createArea(
new ClumpPlacer(diskArea(fractionToTiles(0.38)), 0.9, 0.09, Infinity, peninsulaPosition1),
[
landElevationPainter,
new TileClassPainter(clLand)
]);
g_Map.log("Remembering to not paint shorelines into the peninsula");
let peninsulaPosition2 = Vector2D.add(mapCenter, new Vector2D(fractionToTiles(0.35), 0).rotate(-angle));
createArea(
new ClumpPlacer(diskArea(fractionToTiles(0.33)), 0.9, 0.01, Infinity, peninsulaPosition2),
new TileClassPainter(clPeninsulaSteam));
}
createShoreJaggedness(waterHeight, clLand, 7);
}
function unknownCentralSea()
{
unknownCentralSeaOrIsthmus(false);
}
function unknownIsthmus()
{
unknownCentralSeaOrIsthmus(true);
}
/**
* Creates a huge central river, possibly connecting the riversides with a narrow piece of land.
*/
function unknownCentralSeaOrIsthmus(isthmus)
{
let waterHeight = -3;
let startAngle = randomAngle();
let [riverStart, riverEnd] = centralRiverCoordinates(startAngle);
paintRiver({
"parallel": false,
"start": riverStart,
"end": riverEnd,
"width": fractionToTiles(scaleByMapSize(0.27, 0.42) + randFloat(0, 0.08)),
"fadeDist": scaleByMapSize(3, 12),
"deviation": 0,
"heightRiverbed": waterHeight,
"heightLand": heightLand,
"meanderShort": 20,
"meanderLong": 0,
"waterFunc": (position, height, riverFraction) => {
if (height < 0)
clWater.add(position);
},
"landFunc": (position, shoreDist1, shoreDist2) => {
g_Map.setHeight(position, 3.1);
clLand.add(position);
}
});
if (!isNomad())
{
[playerIDs, playerPosition] = playerPlacementRiver(startAngle + Math.PI / 2, fractionToTiles(0.6));
markPlayerArea("small");
}
if (isthmus)
{
g_Map.log("Creating isthmus (i.e. connecting the two riversides with a big land passage)");
let [isthmusStart, isthmusEnd] = centralRiverCoordinates(startAngle + Math.PI / 2);
createArea(
new PathPlacer(
isthmusStart,
isthmusEnd,
scaleByMapSize(randIntInclusive(16, 24), randIntInclusive(100, 140)),
0.5,
3 * scaleByMapSize(1, 4),
0.1,
0.01),
[
landElevationPainter,
new TileClassPainter(clLand),
new TileClassUnPainter(clWater)
]);
}
createExtensionsOrIslands();
// Don't createShoreJaggedness since it doesn't fit artistically here
}
function unknownCentralRiverLand()
{
unknownCentralRiver(true);
}
function unknownCentralRiverNaval()
{
unknownCentralRiver(false);
}
/**
* Creates a very small central river.
*/
function unknownCentralRiver(shallows)
{
let waterHeight = -4;
let heightShallow = -2;
createArea(
new MapBoundsPlacer(),
new ElevationPainter(heightLand));
let startAngle = randomAngle();
if (!isNomad())
{
[playerIDs, playerPosition] = playerPlacementRiver(startAngle + Math.PI / 2, fractionToTiles(0.5));
markPlayerArea("large");
}
g_Map.log("Creating the main river");
let [coord1, coord2] = centralRiverCoordinates(startAngle);
createArea(
new PathPlacer(coord1, coord2, scaleByMapSize(14, 24), 0.5, scaleByMapSize(3, 12), 0.1, 0.01),
new SmoothElevationPainter(ELEVATION_SET, waterHeight, 4),
avoidClasses(clPlayerTerritory, 4));
g_Map.log("Creating small water spots at the map border to ensure separation of players");
for (let coord of [coord1, coord2])
createArea(
new ClumpPlacer(diskArea(scaleByMapSize(5, 10)), 0.95, 0.6, Infinity, coord),
new SmoothElevationPainter(ELEVATION_SET, waterHeight, 2),
avoidClasses(clPlayerTerritory, 8));
if (shallows)
{
g_Map.log("Creating the shallows of the main river");
for (let i = 0; i <= randIntInclusive(1, scaleByMapSize(4, 8)); ++i)
{
let location = fractionToTiles(randFloat(0.15, 0.85));
createPassage({
"start": new Vector2D(location, mapBounds.top).rotateAround(startAngle, mapCenter),
"end": new Vector2D(location, mapBounds.bottom).rotateAround(startAngle, mapCenter),
"startWidth": scaleByMapSize(8, 12),
"endWidth": scaleByMapSize(8, 12),
"smoothWidth": 2,
"startHeight": heightShallow,
"endHeight": heightShallow,
"constraints": new HeightConstraint(-Infinity, heightShallow),
"tileClass": clShallow
});
}
}
if (randBool(2/3))
createTributaryRivers(
startAngle,
randIntInclusive(8, scaleByMapSize(12, 16)),
scaleByMapSize(10, 20),
-4,
[-6, -1.5],
Math.PI / 5,
clWater,
clShallow,
avoidClasses(clPlayerTerritory, 3));
}
/**
* Creates a circular lake in the middle and possibly a river between each player ("pizza slices").
*/
function unknownRiversAndLake()
{
let waterHeight = -4;
createArea(
new MapBoundsPlacer(),
new ElevationPainter(heightLand));
let startAngle;
if (!isNomad())
{
let playerAngle;
[playerIDs, playerPosition, playerAngle, startAngle] = playerPlacementCircle(fractionToTiles(0.35));
markPlayerArea("small");
}
let lake = randBool(3/4);
if (lake)
{
g_Map.log("Creating lake");
createArea(
new ClumpPlacer(diskArea(fractionToTiles(0.17)), 0.7, 0.1, Infinity, mapCenter),
[
new SmoothElevationPainter(ELEVATION_SET, waterHeight, 4),
new TileClassPainter(clWater)
]);
createShoreJaggedness(waterHeight, clWater, 3);
}
// TODO: On nomad because the resource imbalances per island are too drastic
{
g_Map.log("Creating small rivers separating players");
for (let river of distributePointsOnCircle(numPlayers, startAngle + Math.PI / numPlayers, fractionToTiles(0.5), mapCenter)[0])
{
createArea(
new PathPlacer(mapCenter, river, scaleByMapSize(14, 24), 0.4, 3 * scaleByMapSize(1, 3), 0.2, 0.05),
[
new SmoothElevationPainter(ELEVATION_SET, waterHeight, 4),
new TileClassPainter(clWater)
],
avoidClasses(clPlayer, 5));
createArea(
new ClumpPlacer(diskArea(scaleByMapSize(4, 22)), 0.95, 0.6, Infinity, river),
[
new SmoothElevationPainter(ELEVATION_SET, waterHeight, 0),
new TileClassPainter(clWater)
],
avoidClasses(clPlayer, 5));
}
g_Map.log("Creating small lake");
createArea(
new ClumpPlacer(diskArea(fractionToTiles(0.04)), 0.7, 0.1, Infinity, mapCenter),
[
new SmoothElevationPainter(ELEVATION_SET, waterHeight, 4),
new TileClassPainter(clWater)
]);
}
if (!isNomad && lake && randBool(2/3))
{
g_Map.log("Creating small central island");
createArea(
new ClumpPlacer(diskArea(fractionToTiles(0.05)), 0.7, 0.1, Infinity, mapCenter),
[
landElevationPainter,
new TileClassPainter(clWater)
]);
}
}
/**
* Align players on a land strip with seas bordering on one or both sides that can hold islands.
*/
function unknownEdgeSeas()
{
let waterHeight = -4;
createArea(
new MapBoundsPlacer(),
new ElevationPainter(heightLand));
let startAngle = randomAngle();
if (!isNomad())
{
playerIDs = sortAllPlayers();
playerPosition = playerPlacementLine(startAngle + Math.PI / 2, mapCenter, fractionToTiles(0.2));
// Don't place the shoreline inside the CC, but possibly into the players territory
markPlayerArea("small");
}
for (let side of pickRandom([[0], [Math.PI], [0, Math.PI]]))
paintRiver({
"parallel": true,
"start": new Vector2D(mapBounds.left, mapBounds.top).rotateAround(side + startAngle, mapCenter),
"end": new Vector2D(mapBounds.left, mapBounds.bottom).rotateAround(side + startAngle, mapCenter),
"width": scaleByMapSize(80, randFloat(270, 320)),
"fadeDist": scaleByMapSize(2, 8),
"deviation": 0,
"heightRiverbed": waterHeight,
"heightLand": heightLand,
"meanderShort": 20,
"meanderLong": 0
});
createExtensionsOrIslands();
paintTileClassBasedOnHeight(0, heightCliff, 1, clLand);
createShoreJaggedness(waterHeight, clLand, 7, false);
}
/**
* Land shaped like a concrescent moon around a central lake.
*/
function unknownGulf()
{
let waterHeight = -3;
createArea(
new MapBoundsPlacer(),
new ElevationPainter(heightLand));
let startAngle = randomAngle();
if (!isNomad())
{
g_Map.log("Determining player locations");
playerPosition = playerPlacementCustomAngle(
fractionToTiles(0.35),
mapCenter,
i => startAngle + 2/3 * Math.PI * (-1 + (numPlayers == 1 ? 1 : 2 * i / (numPlayers - 1))))[0];
markPlayerArea("large");
}
let gulfParts = [
{ "radius": fractionToTiles(0.16), "distance": fractionToTiles(0) },
{ "radius": fractionToTiles(0.2), "distance": fractionToTiles(0.2) },
{ "radius": fractionToTiles(0.22), "distance": fractionToTiles(0.49) }
];
for (let gulfPart of gulfParts)
{
let position = Vector2D.sub(mapCenter, new Vector2D(gulfPart.distance, 0).rotate(-startAngle)).round();
createArea(
new ClumpPlacer(diskArea(gulfPart.radius), 0.7, 0.05, Infinity, position),
[
new SmoothElevationPainter(ELEVATION_SET, waterHeight, 4),
new TileClassPainter(clWater)
],
avoidClasses(clPlayerTerritory, defaultPlayerBaseRadius()));
}
}
/**
* Mainland style with some small random lakes.
*/
function unknownLakes()
{
let waterHeight = -5;
createArea(
new MapBoundsPlacer(),
new ElevationPainter(heightLand));
if (!isNomad())
{
[playerIDs, playerPosition] = playerPlacementCircle(fractionToTiles(0.35));
markPlayerArea("large");
}
g_Map.log("Creating lakes");
createAreas(
new ClumpPlacer(scaleByMapSize(160, 700), 0.2, 0.1, Infinity),
[
new SmoothElevationPainter(ELEVATION_SET, waterHeight, 5),
new TileClassPainter(clWater)
],
[avoidClasses(clPlayerTerritory, 12), randBool() ? avoidClasses(clWater, 8) : new NullConstraint()],
scaleByMapSize(5, 16));
}
/**
* A large hill leaving players only a small passage to each of the the two neighboring players.
*/
function unknownPasses()
{
let heightMountain = 24;
let waterHeight = -4;
createArea(
new MapBoundsPlacer(),
new ElevationPainter(heightLand));
let playerAngle;
let startAngle;
if (!isNomad())
{
[playerIDs, playerPosition, playerAngle, startAngle] = playerPlacementCircle(fractionToTiles(0.35));
markPlayerArea("small");
}
else
startAngle = randomAngle();
g_Map.log("Creating a mountain range between neighboring players");
for (let mountain of distributePointsOnCircle(numPlayers, startAngle + Math.PI / numPlayers, fractionToTiles(0.5), mapCenter)[0])
{
createArea(
new PathPlacer(mapCenter, mountain, scaleByMapSize(14, 24), 0.4, 3 * scaleByMapSize(1, 3), 0.2, 0.05),
[
// More smoothing than this often results in the mountainrange becoming passable to one player.
new SmoothElevationPainter(ELEVATION_SET, heightMountain, 1),
new TileClassPainter(clWater)
],
avoidClasses(clPlayer, 5));
// Small mountain at the map border between the players to ensure separation of players
createArea(
new ClumpPlacer(diskArea(scaleByMapSize(4, 22)), 0.95, 0.6, Infinity, mountain),
new SmoothElevationPainter(ELEVATION_SET, heightMountain, 0),
avoidClasses(clPlayer, 5));
}
g_Map.log("Creating passages between neighboring players");
let passes = distributePointsOnCircle(numPlayers * 2, startAngle, fractionToTiles(0.35), mapCenter)[0];
for (let i = 0; i < numPlayers; ++i)
{
createArea(
new PathPlacer(
passes[2 * i],
passes[2 * ((i + 1) % numPlayers)],
scaleByMapSize(14, 24),
0.4,
3 * scaleByMapSize(1, 3),
0.2,
0.05),
new SmoothElevationPainter(ELEVATION_SET, heightLand, 2));
}
if (randBool(2/5))
{
g_Map.log("Create central lake");
createArea(
new ClumpPlacer(diskArea(fractionToTiles(0.1)), 0.7, 0.1, Infinity, mapCenter),
[
new SmoothElevationPainter(ELEVATION_SET, waterHeight, 3),
new TileClassPainter(clWater)
]);
}
else
{
g_Map.log("Fill area between the paths");
createArea(
new ClumpPlacer(diskArea(fractionToTiles(0.05)), 0.7, 0.1, Infinity, mapCenter),
[
new SmoothElevationPainter(ELEVATION_SET, heightMountain, 4),
new TileClassPainter(clWater)
]);
}
}
/**
* Land enclosed by a hill that leaves small areas for civic centers and large central place.
*/
function unknownLowlands()
{
let heightMountain = 30;
g_Map.log("Creating mountain that is going to separate players");
createArea(
new MapBoundsPlacer(),
new ElevationPainter(heightMountain));
let playerAngle;
let startAngle;
if (!isNomad())
{
[playerIDs, playerPosition, playerAngle, startAngle] = playerPlacementCircle(fractionToTiles(0.35));
markPlayerArea("small");
}
else
startAngle = randomAngle();
g_Map.log("Creating valleys enclosed by the mountain");
let valleys = numPlayers;
if (mapSize >= 128 && numPlayers <= 2 ||
mapSize >= 192 && numPlayers <= 3 ||
mapSize >= 320 && numPlayers <= 4 ||
mapSize >= 384 && numPlayers <= 5 ||
mapSize >= 448 && numPlayers <= 6)
valleys *= 2;
g_Map.log("Creating player valley");
for (let valley of distributePointsOnCircle(valleys, startAngle, fractionToTiles(0.35), mapCenter)[0])
{
createArea(
new ClumpPlacer(diskArea(scaleByMapSize(18, 32)), 0.65, 0.1, Infinity, valley),
[
new SmoothElevationPainter(ELEVATION_SET, heightLand, 2),
new TileClassPainter(clLand)
]);
// Passage from player to center
createArea(
new PathPlacer(mapCenter, valley, scaleByMapSize(14, 24), 0.4, 3 * scaleByMapSize(1, 3), 0.2, 0.05),
[
landElevationPainter,
new TileClassPainter(clWater)
]);
}
g_Map.log("Creating the big central area");
createArea(
new ClumpPlacer(diskArea(fractionToTiles(0.18)), 0.7, 0.1, Infinity, mapCenter),
[
landElevationPainter,
new TileClassPainter(clWater)
]);
}
/**
* No water, no hills.
*/
function unknownMainland()
{
createArea(
new MapBoundsPlacer(),
new ElevationPainter(3));
if (!isNomad())
{
[playerIDs, playerPosition] = playerPlacementCircle(fractionToTiles(0.35));
markPlayerArea("small");
}
}
function centralRiverCoordinates(angle)
{
return [
new Vector2D(mapBounds.left + 1, mapCenter.y),
new Vector2D(mapBounds.right - 1, mapCenter.y)
].map(v => v.rotateAround(angle, mapCenter));
}
function createShoreJaggedness(waterHeight, borderClass, shoreDist, inwards = true)
{
g_Map.log("Creating shore jaggedness");
for (let i = 0; i < 2; ++i)
if (i || inwards)
createAreas(
new ChainPlacer(2, Math.floor(scaleByMapSize(4, 6)), 15, Infinity),
[
new SmoothElevationPainter(ELEVATION_SET, i ? heightLand : waterHeight, 4),
i ? new TileClassPainter(clLand) : new TileClassUnPainter(clLand)
],
[
avoidClasses(clPlayer, 20, clPeninsulaSteam, 20),
borderClasses(borderClass, shoreDist, shoreDist)
],
scaleByMapSize(7, 130) * 2,
150);
}
function createExtensionsOrIslands()
{
let rnd = randIntInclusive(1, 3);
if (rnd == 1)
{
g_Map.log("Creating islands");
createAreas(
new ClumpPlacer(Math.square(randIntInclusive(scaleByMapSize(8, 15), scaleByMapSize(15, 23))), 0.8, 0.1, randFloat(0, 0.2)),
[
landElevationPainter,
new TileClassPainter(clLand)
],
avoidClasses(clLand, 3, clPlayer, 3),
scaleByMapSize(2, 5) * randIntInclusive(8, 14));
}
else if (rnd == 2)
{
g_Map.log("Creating extentions");
createAreas(
new ChainPlacer(Math.floor(scaleByMapSize(4, 7)), Math.floor(scaleByMapSize(7, 10)), Math.floor(scaleByMapSize(16, 40)), 0.07),
[
landElevationPainter,
new TileClassPainter(clLand)
],
null,
scaleByMapSize(2, 5) * randIntInclusive(8, 14));
}
}
/**
* Prevent impassable terrain and resource collisions at the the civic center and starting resources.
*/
function markPlayerArea(size)
{
for (let i = 0; i < numPlayers; ++i)
{
addCivicCenterAreaToClass(playerPosition[i], clPlayer);
if (size == "large")
createArea(
new ClumpPlacer(diskArea(scaleByMapSize(17, 29) / 3), 0.6, 0.3, Infinity, playerPosition[i]),
new TileClassPainter(clPlayerTerritory));
}
}
function paintUnknownMapBasedOnHeight()
{
paintTerrainBasedOnHeight(heightCliff, 40, 1, tCliff);
paintTerrainBasedOnHeight(3, heightCliff, 1, tMainTerrain);
paintTerrainBasedOnHeight(1, 3, 1, tShore);
paintTerrainBasedOnHeight(-8, 1, 2, tWater);
unPaintTileClassBasedOnHeight(0, heightCliff, 1, clWater);
unPaintTileClassBasedOnHeight(-6, 0, 1, clLand);
paintTileClassBasedOnHeight(-6, 0, 1, clWater);
paintTileClassBasedOnHeight(0, heightCliff, 1, clLand);
paintTileClassBasedOnHeight(heightCliff, 40, 1, clHill);
}
/**
* Place resources and decoratives after the player territory was marked.
*/
function createUnknownObjects()
{
g_Map.log("Creating bumps");
createAreas(
new ClumpPlacer(scaleByMapSize(20, 50), 0.3, 0.06, Infinity),
new SmoothElevationPainter(ELEVATION_MODIFY, heightOffsetBump, 2),
[avoidClasses(clWater, 2, clPlayer, 10), stayClasses(clLand, 3)],
randIntInclusive(0, scaleByMapSize(1, 2) * 200));
g_Map.log("Creating hills");
createAreas(
new ClumpPlacer(scaleByMapSize(20, 150), 0.2, 0.1, Infinity),
[
new LayeredPainter([tCliff, tHill], [2]),
new SmoothElevationPainter(ELEVATION_SET, heightHill, 2),
new TileClassPainter(clHill)
],
[avoidClasses(clPlayer, 15, clHill, randIntInclusive(6, 18)), stayClasses(clLand, 0)],
randIntInclusive(0, scaleByMapSize(4, 8))*randIntInclusive(1, scaleByMapSize(4, 9))
);
Engine.SetProgress(30);
g_Map.log("Creating forests");
let [numForest, numStragglers] = getTreeCounts(...rBiomeTreeCount(1));
let types = [
[[tForestFloor2, tMainTerrain, pForest1], [tForestFloor2, pForest1]],
[[tForestFloor1, tMainTerrain, pForest2], [tForestFloor1, pForest2]]
];
let size = numForest / (scaleByMapSize(2, 8) * numPlayers);
let num = Math.floor(size / types.length);
for (let type of types)
createAreas(
new ClumpPlacer(numForest / num, 0.1, 0.1, Infinity),
[
new LayeredPainter(type, [2]),
new TileClassPainter(clForest)
],
[avoidClasses(clPlayer, 20, clForest, randIntInclusive(5, 15), clHill, 2), stayClasses(clLand, 4)],
num);
Engine.SetProgress(50);
g_Map.log("Creating dirt patches");
let patchCount = (currentBiome() == "generic/savanna" ? 3 : 1) * scaleByMapSize(15, 45);
for (let patchSize of [scaleByMapSize(3, 48), scaleByMapSize(5, 84), scaleByMapSize(8, 128)])
createAreas(
new ClumpPlacer(patchSize, 0.3, 0.06, 0.5),
[
new LayeredPainter([[tMainTerrain, tTier1Terrain], [tTier1Terrain, tTier2Terrain], [tTier2Terrain, tTier3Terrain]], [1, 1]),
new TileClassPainter(clDirt)
],
[avoidClasses(clForest, 0, clHill, 2, clDirt, 5, clPlayer, 7), stayClasses(clLand, 4)],
patchCount);
g_Map.log("Creating grass patches");
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(tTier4Terrain),
[avoidClasses(clForest, 0, clHill, 2, clDirt, 5, clPlayer, 7), stayClasses(clLand, 4)],
patchCount);
Engine.SetProgress(55);
g_Map.log("Creating stone mines");
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(oStoneSmall, 0, 2, 0, 4, 0, 2 * Math.PI, 1), new SimpleObject(oStoneLarge, 1, 1, 0, 4, 0, 2 * Math.PI, 4)], true, clRock),
0,
[avoidClasses(clForest, 1, clPlayer, 10, clRock, 10, clHill, 2), stayClasses(clLand, 3)],
randIntInclusive(scaleByMapSize(2, 9), scaleByMapSize(9, 40)),
100);
g_Map.log("Creating small stone quarries");
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(oStoneSmall, 2, 5, 1, 3)], true, clRock),
0,
[avoidClasses(clForest, 1, clPlayer, 10, clRock, 10, clHill, 2), stayClasses(clLand, 3)],
randIntInclusive(scaleByMapSize(2, 9), scaleByMapSize(9, 40)),
100);
g_Map.log("Creating metal mines");
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(oMetalLarge, 1, 1, 0, 4)], true, clMetal),
0,
[avoidClasses(clForest, 1, clPlayer, 10, clMetal, 10, clRock, 5, clHill, 2), stayClasses(clLand, 3)],
randIntInclusive(scaleByMapSize(2, 9), scaleByMapSize(9, 40)),
100);
Engine.SetProgress(65);
g_Map.log("Creating small decorative rocks");
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(aRockMedium, 1, 3, 0, 1)], true),
0,
[avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 2), stayClasses(clLand, 3)],
scaleByMapSize(16, 262),
50);
g_Map.log("Creating large decorative rocks");
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(aRockLarge, 1, 2, 0, 1), new SimpleObject(aRockMedium, 1, 3, 0, 2)], true),
0,
[avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 2), stayClasses(clLand, 3)],
scaleByMapSize(8, 131),
50);
Engine.SetProgress(70);
g_Map.log("Creating deer");
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(oMainHuntableAnimal, 5, 7, 0, 4)], true, clFood),
0,
[avoidClasses(clWater, 0, clForest, 0, clPlayer, 8, clHill, 2, clFood, 20), stayClasses(clLand, 2)],
randIntInclusive(numPlayers + 3, 5 * numPlayers + 4),
50);
g_Map.log("Creating berry bush");
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(oFruitBush, 5, 7, 0, 4)], true, clFood),
0,
[avoidClasses(clWater, 0, clForest, 0, clPlayer, 8, clHill, 2, clFood, 20), stayClasses(clLand, 2)],
randIntInclusive(1, 4) * numPlayers + 2,
50);
Engine.SetProgress(75);
g_Map.log("Creating sheep");
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(oSecondaryHuntableAnimal, 2, 3, 0, 2)], true, clFood),
0,
[avoidClasses(clWater, 0, clForest, 0, clPlayer, 8, clHill, 2, clFood, 20), stayClasses(clLand, 2)],
randIntInclusive(numPlayers + 3, 5 * numPlayers + 4),
50);
g_Map.log("Creating fish");
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(oFish, 2, 3, 0, 2)], true, clFood),
0,
avoidClasses(clLand, 4, clForest, 0, clPlayer, 0, clHill, 2, clFood, 20),
randIntInclusive(15, 40) * numPlayers,
60);
Engine.SetProgress(85);
g_Map.log("Creating straggler trees");
types = [g_Gaia.tree1, g_Gaia.tree2, g_Gaia.tree3, g_Gaia.tree4];
num = Math.floor(numStragglers / types.length);
for (let type of types)
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(type, 1, 1, 0, 3)], true, clForest),
0,
[avoidClasses(clWater, 1, clForest, 1, clHill, 2, clPlayer, 0, clMetal, 6, clRock, 6, clBaseResource, 6), stayClasses(clLand, 4)],
num);
let planetm = currentBiome() == "generic/india" ? 8 : 1;
g_Map.log("Creating small grass tufts");
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(aGrassShort, 1, 2, 0, 1, -Math.PI / 8, Math.PI / 8)]),
0,
[avoidClasses(clWater, 2, clHill, 2, clPlayer, 2, clDirt, 0), stayClasses(clLand, 3)],
planetm * scaleByMapSize(13, 200));
Engine.SetProgress(90);
g_Map.log("Creating large grass tufts");
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(aGrass, 2, 4, 0, 1.8, -Math.PI / 8, Math.PI / 8), new SimpleObject(aGrassShort, 3, 6, 1.2, 2.5, -Math.PI / 8, Math.PI / 8)]),
0,
[avoidClasses(clWater, 3, clHill, 2, clPlayer, 2, clDirt, 1, clForest, 0), stayClasses(clLand, 3)],
planetm * scaleByMapSize(13, 200));
Engine.SetProgress(95);
g_Map.log("Creating shallow flora");
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(aLillies, 1, 2, 0, 2), new SimpleObject(aReeds, 2, 4, 0, 2)]),
0,
stayClasses(clShallow, 1),
60 * scaleByMapSize(13, 200),
80);
g_Map.log("Creating bushes");
createObjectGroupsDeprecated(
new SimpleGroup([new SimpleObject(aBushMedium, 1, 2, 0, 2), new SimpleObject(aBushSmall, 2, 4, 0, 2)]),
0,
[avoidClasses(clWater, 1, clHill, 2, clPlayer, 1, clDirt, 1), stayClasses(clLand, 3)],
planetm * scaleByMapSize(13, 200),
50);
setSkySet(pickRandom(["cirrus", "cumulus", "sunny", "sunny 1", "mountainous", "stratus"]));
setSunRotation(randomAngle());
setSunElevation(Math.PI * randFloat(1/5, 1/3));
}
function createUnknownPlayerBases()
{
placePlayerBases({
"PlayerPlacement": [playerIDs, playerPosition],
"BaseResourceClass": clBaseResource,
"Walls": g_StartingWalls,
"CityPatch": {
"outerTerrain": tRoadWild,
"innerTerrain": tRoad,
"painters": [
new TileClassPainter(clPlayer)
]
},
"Chicken": {
},
"Berries": {
"template": oFruitBush
},
"Mines": {
"types": [
{ "template": oMetalLarge },
{ "template": oStoneLarge }
]
},
"Treasures": {
"types": [
{
"template": oWoodTreasure,
"count": g_StartingTreasures ? 14 : 0
}
]
},
"Trees": {
"template": oTree1
},
"Decoratives": {
"template": aGrassShort
}
});
}
createUnknownMap();
g_Map.ExportMap();
Index: ps/trunk/source/ps/GameSetup/GameSetup.cpp
===================================================================
--- ps/trunk/source/ps/GameSetup/GameSetup.cpp (revision 25764)
+++ ps/trunk/source/ps/GameSetup/GameSetup.cpp (revision 25765)
@@ -1,1625 +1,1629 @@
/* Copyright (C) 2021 Wildfire Games.
* This file is part of 0 A.D.
*
* 0 A.D. is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* 0 A.D. is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with 0 A.D. If not, see .
*/
#include "precompiled.h"
#include "lib/app_hooks.h"
#include "lib/config2.h"
#include "lib/input.h"
#include "lib/ogl.h"
#include "lib/timer.h"
#include "lib/external_libraries/libsdl.h"
#include "lib/file/common/file_stats.h"
#include "lib/res/h_mgr.h"
#include "lib/res/graphics/cursor.h"
#include "graphics/CinemaManager.h"
#include "graphics/Color.h"
#include "graphics/GameView.h"
#include "graphics/LightEnv.h"
#include "graphics/MapReader.h"
#include "graphics/ModelDef.h"
#include "graphics/MaterialManager.h"
#include "graphics/TerrainTextureManager.h"
#include "gui/CGUI.h"
#include "gui/GUIManager.h"
#include "i18n/L10n.h"
#include "maths/MathUtil.h"
#include "network/NetServer.h"
#include "network/NetClient.h"
#include "network/NetMessage.h"
#include "network/NetMessages.h"
#include "ps/CConsole.h"
#include "ps/CLogger.h"
#include "ps/ConfigDB.h"
#include "ps/Filesystem.h"
#include "ps/Game.h"
#include "ps/GameSetup/Atlas.h"
#include "ps/GameSetup/GameSetup.h"
#include "ps/GameSetup/Paths.h"
#include "ps/GameSetup/Config.h"
#include "ps/GameSetup/CmdLineArgs.h"
#include "ps/GameSetup/HWDetect.h"
#include "ps/Globals.h"
#include "ps/GUID.h"
#include "ps/Hotkey.h"
#include "ps/Joystick.h"
#include "ps/Loader.h"
#include "ps/Mod.h"
#include "ps/ModIo.h"
#include "ps/Profile.h"
#include "ps/ProfileViewer.h"
#include "ps/Profiler2.h"
#include "ps/Pyrogenesis.h" // psSetLogDir
#include "ps/scripting/JSInterface_Console.h"
#include "ps/TouchInput.h"
#include "ps/UserReport.h"
#include "ps/Util.h"
#include "ps/VideoMode.h"
#include "ps/VisualReplay.h"
#include "ps/World.h"
#include "renderer/Renderer.h"
#include "renderer/VertexBufferManager.h"
#include "renderer/ModelRenderer.h"
#include "scriptinterface/FunctionWrapper.h"
#include "scriptinterface/ScriptInterface.h"
#include "scriptinterface/ScriptStats.h"
#include "scriptinterface/ScriptContext.h"
#include "scriptinterface/ScriptConversions.h"
#include "scriptinterface/JSON.h"
#include "simulation2/Simulation2.h"
#include "lobby/IXmppClient.h"
#include "soundmanager/scripting/JSInterface_Sound.h"
#include "soundmanager/ISoundManager.h"
#include "tools/atlas/GameInterface/GameLoop.h"
#include "tools/atlas/GameInterface/View.h"
#if !(OS_WIN || OS_MACOSX || OS_ANDROID) // assume all other platforms use X11 for wxWidgets
#define MUST_INIT_X11 1
#include
#else
#define MUST_INIT_X11 0
#endif
extern void RestartEngine();
#include
#include
#include
#include
#include
ERROR_GROUP(System);
ERROR_TYPE(System, SDLInitFailed);
ERROR_TYPE(System, VmodeFailed);
ERROR_TYPE(System, RequiredExtensionsMissing);
bool g_DoRenderGui = true;
bool g_DoRenderLogger = true;
bool g_DoRenderCursor = true;
thread_local std::shared_ptr g_ScriptContext;
static const int SANE_TEX_QUALITY_DEFAULT = 5; // keep in sync with code
static const CStr g_EventNameGameLoadProgress = "GameLoadProgress";
bool g_InDevelopmentCopy;
bool g_CheckedIfInDevelopmentCopy = false;
static void SetTextureQuality(int quality)
{
int q_flags;
GLint filter;
retry:
// keep this in sync with SANE_TEX_QUALITY_DEFAULT
switch(quality)
{
// worst quality
case 0:
q_flags = OGL_TEX_HALF_RES|OGL_TEX_HALF_BPP;
filter = GL_NEAREST;
break;
// [perf] add bilinear filtering
case 1:
q_flags = OGL_TEX_HALF_RES|OGL_TEX_HALF_BPP;
filter = GL_LINEAR;
break;
// [vmem] no longer reduce resolution
case 2:
q_flags = OGL_TEX_HALF_BPP;
filter = GL_LINEAR;
break;
// [vmem] add mipmaps
case 3:
q_flags = OGL_TEX_HALF_BPP;
filter = GL_NEAREST_MIPMAP_LINEAR;
break;
// [perf] better filtering
case 4:
q_flags = OGL_TEX_HALF_BPP;
filter = GL_LINEAR_MIPMAP_LINEAR;
break;
// [vmem] no longer reduce bpp
case SANE_TEX_QUALITY_DEFAULT:
q_flags = OGL_TEX_FULL_QUALITY;
filter = GL_LINEAR_MIPMAP_LINEAR;
break;
// [perf] add anisotropy
case 6:
// TODO: add anisotropic filtering
q_flags = OGL_TEX_FULL_QUALITY;
filter = GL_LINEAR_MIPMAP_LINEAR;
break;
// invalid
default:
debug_warn(L"SetTextureQuality: invalid quality");
quality = SANE_TEX_QUALITY_DEFAULT;
// careful: recursion doesn't work and we don't want to duplicate
// the "sane" default values.
goto retry;
}
ogl_tex_set_defaults(q_flags, filter);
}
//----------------------------------------------------------------------------
// GUI integration
//----------------------------------------------------------------------------
// display progress / description in loading screen
void GUI_DisplayLoadProgress(int percent, const wchar_t* pending_task)
{
const ScriptInterface& scriptInterface = *(g_GUI->GetActiveGUI()->GetScriptInterface());
ScriptRequest rq(scriptInterface);
JS::RootedValueVector paramData(rq.cx);
ignore_result(paramData.append(JS::NumberValue(percent)));
JS::RootedValue valPendingTask(rq.cx);
Script::ToJSVal(rq, &valPendingTask, pending_task);
ignore_result(paramData.append(valPendingTask));
g_GUI->SendEventToAll(g_EventNameGameLoadProgress, paramData);
}
bool ShouldRender()
{
return !g_app_minimized && (g_app_has_focus || !g_VideoMode.IsInFullscreen());
}
void Render()
{
// Do not render if not focused while in fullscreen or minimised,
// as that triggers a difficult-to-reproduce crash on some graphic cards.
if (!ShouldRender())
return;
PROFILE3("render");
g_Profiler2.RecordGPUFrameStart();
ogl_WarnIfError();
// prepare before starting the renderer frame
if (g_Game && g_Game->IsGameStarted())
g_Game->GetView()->BeginFrame();
if (g_Game)
g_Renderer.SetSimulation(g_Game->GetSimulation2());
// start new frame
g_Renderer.BeginFrame();
ogl_WarnIfError();
if (g_Game && g_Game->IsGameStarted())
{
g_Game->GetView()->Render();
ogl_WarnIfError();
}
g_Renderer.RenderTextOverlays();
// If we're in Atlas game view, render special tools
if (g_AtlasGameLoop && g_AtlasGameLoop->view)
{
g_AtlasGameLoop->view->DrawCinemaPathTool();
ogl_WarnIfError();
}
if (g_Game && g_Game->IsGameStarted())
{
g_Game->GetView()->GetCinema()->Render();
ogl_WarnIfError();
}
glDisable(GL_DEPTH_TEST);
if (g_DoRenderGui)
{
// All GUI elements are drawn in Z order to render semi-transparent
// objects correctly.
g_GUI->Draw();
ogl_WarnIfError();
}
// If we're in Atlas game view, render special overlays (e.g. editor bandbox).
if (g_AtlasGameLoop && g_AtlasGameLoop->view)
{
g_AtlasGameLoop->view->DrawOverlays();
ogl_WarnIfError();
}
g_Console->Render();
ogl_WarnIfError();
if (g_DoRenderLogger)
{
g_Logger->Render();
ogl_WarnIfError();
}
// Profile information
g_ProfileViewer.RenderProfile();
ogl_WarnIfError();
// Draw the cursor (or set the Windows cursor, on Windows)
if (g_DoRenderCursor)
{
PROFILE3_GPU("cursor");
CStrW cursorName = g_CursorName;
if (cursorName.empty())
{
cursor_draw(g_VFS, NULL, g_mouse_x, g_yres-g_mouse_y, g_GuiScale, false);
}
else
{
bool forceGL = false;
CFG_GET_VAL("nohwcursor", forceGL);
#if CONFIG2_GLES
#warning TODO: implement cursors for GLES
#else
// set up transform for GL cursor
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
CMatrix3D transform;
transform.SetOrtho(0.f, (float)g_xres, 0.f, (float)g_yres, -1.f, 1000.f);
glLoadMatrixf(&transform._11);
#endif
#if OS_ANDROID
#warning TODO: cursors for Android
#else
if (cursor_draw(g_VFS, cursorName.c_str(), g_mouse_x, g_yres-g_mouse_y, g_GuiScale, forceGL) < 0)
LOGWARNING("Failed to draw cursor '%s'", utf8_from_wstring(cursorName));
#endif
#if CONFIG2_GLES
#warning TODO: implement cursors for GLES
#else
// restore transform
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
#endif
}
}
glEnable(GL_DEPTH_TEST);
g_Renderer.EndFrame();
PROFILE2_ATTR("draw calls: %d", (int)g_Renderer.GetStats().m_DrawCalls);
PROFILE2_ATTR("terrain tris: %d", (int)g_Renderer.GetStats().m_TerrainTris);
PROFILE2_ATTR("water tris: %d", (int)g_Renderer.GetStats().m_WaterTris);
PROFILE2_ATTR("model tris: %d", (int)g_Renderer.GetStats().m_ModelTris);
PROFILE2_ATTR("overlay tris: %d", (int)g_Renderer.GetStats().m_OverlayTris);
PROFILE2_ATTR("blend splats: %d", (int)g_Renderer.GetStats().m_BlendSplats);
PROFILE2_ATTR("particles: %d", (int)g_Renderer.GetStats().m_Particles);
ogl_WarnIfError();
g_Profiler2.RecordGPUFrameEnd();
ogl_WarnIfError();
}
ErrorReactionInternal psDisplayError(const wchar_t* UNUSED(text), size_t UNUSED(flags))
{
// If we're fullscreen, then sometimes (at least on some particular drivers on Linux)
// displaying the error dialog hangs the desktop since the dialog box is behind the
// fullscreen window. So we just force the game to windowed mode before displaying the dialog.
// (But only if we're in the main thread, and not if we're being reentrant.)
if (Threading::IsMainThread())
{
static bool reentering = false;
if (!reentering)
{
reentering = true;
g_VideoMode.SetFullscreen(false);
reentering = false;
}
}
// We don't actually implement the error display here, so return appropriately
return ERI_NOT_IMPLEMENTED;
}
void MountMods(const Paths& paths, const std::vector& mods)
{
OsPath modPath = paths.RData()/"mods";
OsPath modUserPath = paths.UserData()/"mods";
size_t userFlags = VFS_MOUNT_WATCH|VFS_MOUNT_ARCHIVABLE;
size_t baseFlags = userFlags|VFS_MOUNT_MUST_EXIST;
size_t priority = 0;
for (size_t i = 0; i < mods.size(); ++i)
{
priority = i + 1; // Mods are higher priority than regular mountings, which default to priority 0
OsPath modName(mods[i]);
// Only mount mods from the user path if they don't exist in the 'rdata' path.
if (DirectoryExists(modPath / modName / ""))
g_VFS->Mount(L"", modPath / modName / "", baseFlags, priority);
else
g_VFS->Mount(L"", modUserPath / modName / "", userFlags, priority);
}
// Mount the user mod last. In dev copy, mount it with a low priority. Otherwise, make it writable.
g_VFS->Mount(L"", modUserPath / "user" / "", userFlags, InDevelopmentCopy() ? 0 : priority + 1);
}
static void InitVfs(const CmdLineArgs& args, int flags)
{
TIMER(L"InitVfs");
const bool setup_error = (flags & INIT_HAVE_DISPLAY_ERROR) == 0;
const Paths paths(args);
OsPath logs(paths.Logs());
CreateDirectories(logs, 0700);
psSetLogDir(logs);
// desired location for crashlog is now known. update AppHooks ASAP
// (particularly before the following error-prone operations):
AppHooks hooks = {0};
hooks.bundle_logs = psBundleLogs;
hooks.get_log_dir = psLogDir;
if (setup_error)
hooks.display_error = psDisplayError;
app_hooks_update(&hooks);
g_VFS = CreateVfs();
const OsPath readonlyConfig = paths.RData()/"config"/"";
// Mount these dirs with highest priority so that mods can't overwrite them.
g_VFS->Mount(L"cache/", paths.Cache(), VFS_MOUNT_ARCHIVABLE, VFS_MAX_PRIORITY); // (adding XMBs to archive speeds up subsequent reads)
if (readonlyConfig != paths.Config())
g_VFS->Mount(L"config/", readonlyConfig, 0, VFS_MAX_PRIORITY-1);
g_VFS->Mount(L"config/", paths.Config(), 0, VFS_MAX_PRIORITY);
g_VFS->Mount(L"screenshots/", paths.UserData()/"screenshots"/"", 0, VFS_MAX_PRIORITY);
g_VFS->Mount(L"saves/", paths.UserData()/"saves"/"", VFS_MOUNT_WATCH, VFS_MAX_PRIORITY);
// Engine localization files (regular priority, these can be overwritten).
g_VFS->Mount(L"l10n/", paths.RData()/"l10n"/"");
// Mods will be mounted later.
// note: don't bother with g_VFS->TextRepresentation - directories
// haven't yet been populated and are empty.
}
static void InitPs(bool setup_gui, const CStrW& gui_page, ScriptInterface* srcScriptInterface, JS::HandleValue initData)
{
{
// console
TIMER(L"ps_console");
g_Console->Init();
}
// hotkeys
{
TIMER(L"ps_lang_hotkeys");
LoadHotkeys(g_ConfigDB);
}
if (!setup_gui)
{
// We do actually need *some* kind of GUI loaded, so use the
// (currently empty) Atlas one
g_GUI->SwitchPage(L"page_atlas.xml", srcScriptInterface, initData);
return;
}
// GUI uses VFS, so this must come after VFS init.
g_GUI->SwitchPage(gui_page, srcScriptInterface, initData);
}
void InitPsAutostart(bool networked, JS::HandleValue attrs)
{
// The GUI has not been initialized yet, so use the simulation scriptinterface for this variable
ScriptInterface& scriptInterface = g_Game->GetSimulation2()->GetScriptInterface();
ScriptRequest rq(scriptInterface);
JS::RootedValue playerAssignments(rq.cx);
Script::CreateObject(rq, &playerAssignments);
if (!networked)
{
JS::RootedValue localPlayer(rq.cx);
Script::CreateObject(rq, &localPlayer, "player", g_Game->GetPlayerID());
Script::SetProperty(rq, playerAssignments, "local", localPlayer);
}
JS::RootedValue sessionInitData(rq.cx);
Script::CreateObject(
rq,
&sessionInitData,
"attribs", attrs,
"playerAssignments", playerAssignments);
InitPs(true, L"page_loading.xml", &scriptInterface, sessionInitData);
}
void InitInput()
{
g_Joystick.Initialise();
// register input handlers
// This stack is constructed so the first added, will be the last
// one called. This is important, because each of the handlers
// has the potential to block events to go further down
// in the chain. I.e. the last one in the list added, is the
// only handler that can block all messages before they are
// processed.
in_add_handler(game_view_handler);
in_add_handler(CProfileViewer::InputThunk);
in_add_handler(HotkeyInputActualHandler);
// gui_handler needs to be registered after (i.e. called before!) the
// hotkey handler so that input boxes can be typed in without
// setting off hotkeys.
in_add_handler(gui_handler);
// Likewise for the console.
in_add_handler(conInputHandler);
in_add_handler(touch_input_handler);
// Should be called after scancode map update (i.e. after the global input, but before UI).
// This never blocks the event, but it does some processing necessary for hotkeys,
// which are triggered later down the input chain.
// (by calling this before the UI, we can use 'EventWouldTriggerHotkey' in the UI).
in_add_handler(HotkeyInputPrepHandler);
// These two must be called first (i.e. pushed last)
// GlobalsInputHandler deals with some important global state,
// such as which scancodes are being pressed, mouse buttons pressed, etc.
// while HotkeyStateChange updates the map of active hotkeys.
in_add_handler(GlobalsInputHandler);
in_add_handler(HotkeyStateChange);
}
static void ShutdownPs()
{
SAFE_DELETE(g_GUI);
UnloadHotkeys();
// disable the special Windows cursor, or free textures for OGL cursors
cursor_draw(g_VFS, 0, g_mouse_x, g_yres-g_mouse_y, 1.0, false);
}
static void InitRenderer()
{
TIMER(L"InitRenderer");
// create renderer
new CRenderer;
// create terrain related stuff
new CTerrainTextureManager;
g_Renderer.Open(g_xres, g_yres);
// Setup lighting environment. Since the Renderer accesses the
// lighting environment through a pointer, this has to be done before
// the first Frame.
g_Renderer.SetLightEnv(&g_LightEnv);
// I haven't seen the camera affecting GUI rendering and such, but the
// viewport has to be updated according to the video mode
SViewPort vp;
vp.m_X = 0;
vp.m_Y = 0;
vp.m_Width = g_xres;
vp.m_Height = g_yres;
g_Renderer.SetViewport(vp);
ModelDefActivateFastImpl();
ColorActivateFastImpl();
ModelRenderer::Init();
}
static void InitSDL()
{
#if OS_LINUX
// In fullscreen mode when SDL is compiled with DGA support, the mouse
// sensitivity often appears to be unusably wrong (typically too low).
// (This seems to be reported almost exclusively on Ubuntu, but can be
// reproduced on Gentoo after explicitly enabling DGA.)
// Disabling the DGA mouse appears to fix that problem, and doesn't
// have any obvious negative effects.
setenv("SDL_VIDEO_X11_DGAMOUSE", "0", 0);
#endif
if(SDL_Init(SDL_INIT_VIDEO|SDL_INIT_TIMER|SDL_INIT_NOPARACHUTE) < 0)
{
LOGERROR("SDL library initialization failed: %s", SDL_GetError());
throw PSERROR_System_SDLInitFailed();
}
atexit(SDL_Quit);
// Text input is active by default, disable it until it is actually needed.
SDL_StopTextInput();
#if SDL_VERSION_ATLEAST(2, 0, 9)
// SDL2 >= 2.0.9 defaults to 32 pixels (to support touch screens) but that can break our double-clicking.
SDL_SetHint(SDL_HINT_MOUSE_DOUBLE_CLICK_RADIUS, "1");
#endif
#if OS_MACOSX
// Some Mac mice only have one button, so they can't right-click
// but SDL2 can emulate that with Ctrl+Click
bool macMouse = false;
CFG_GET_VAL("macmouse", macMouse);
SDL_SetHint(SDL_HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK, macMouse ? "1" : "0");
#endif
}
static void ShutdownSDL()
{
SDL_Quit();
}
void EndGame()
{
SAFE_DELETE(g_NetClient);
SAFE_DELETE(g_NetServer);
SAFE_DELETE(g_Game);
if (CRenderer::IsInitialised())
{
ISoundManager::CloseGame();
g_Renderer.ResetState();
}
}
void Shutdown(int flags)
{
const bool hasRenderer = CRenderer::IsInitialised();
if ((flags & SHUTDOWN_FROM_CONFIG))
goto from_config;
EndGame();
SAFE_DELETE(g_XmppClient);
SAFE_DELETE(g_ModIo);
ShutdownPs();
TIMER_BEGIN(L"shutdown TexMan");
delete &g_TexMan;
TIMER_END(L"shutdown TexMan");
if (hasRenderer)
{
TIMER_BEGIN(L"shutdown Renderer");
g_Renderer.~CRenderer();
g_VBMan.Shutdown();
TIMER_END(L"shutdown Renderer");
}
g_RenderingOptions.ClearHooks();
g_Profiler2.ShutdownGPU();
// Free cursors before shutting down SDL, as they may depend on SDL.
cursor_shutdown();
TIMER_BEGIN(L"shutdown SDL");
ShutdownSDL();
TIMER_END(L"shutdown SDL");
if (hasRenderer)
g_VideoMode.Shutdown();
TIMER_BEGIN(L"shutdown UserReporter");
g_UserReporter.Deinitialize();
TIMER_END(L"shutdown UserReporter");
// Cleanup curl now that g_ModIo and g_UserReporter have been shutdown.
curl_global_cleanup();
delete &g_L10n;
from_config:
TIMER_BEGIN(L"shutdown ConfigDB");
CConfigDB::Shutdown();
TIMER_END(L"shutdown ConfigDB");
SAFE_DELETE(g_Console);
// This is needed to ensure that no callbacks from the JSAPI try to use
// the profiler when it's already destructed
g_ScriptContext.reset();
// resource
// first shut down all resource owners, and then the handle manager.
TIMER_BEGIN(L"resource modules");
ISoundManager::SetEnabled(false);
g_VFS.reset();
// this forcibly frees all open handles (thus preventing real leaks),
// and makes further access to h_mgr impossible.
h_mgr_shutdown();
file_stats_dump();
TIMER_END(L"resource modules");
TIMER_BEGIN(L"shutdown misc");
timer_DisplayClientTotals();
CNetHost::Deinitialize();
// should be last, since the above use them
SAFE_DELETE(g_Logger);
delete &g_Profiler;
delete &g_ProfileViewer;
SAFE_DELETE(g_ScriptStatsTable);
TIMER_END(L"shutdown misc");
}
#if OS_UNIX
static void FixLocales()
{
#if OS_MACOSX || OS_BSD
// OS X requires a UTF-8 locale in LC_CTYPE so that *wprintf can handle
// wide characters. Peculiarly the string "UTF-8" seems to be acceptable
// despite not being a real locale, and it's conveniently language-agnostic,
// so use that.
setlocale(LC_CTYPE, "UTF-8");
#endif
// On misconfigured systems with incorrect locale settings, we'll die
// with a C++ exception when some code (e.g. Boost) tries to use locales.
// To avoid death, we'll detect the problem here and warn the user and
// reset to the default C locale.
// For informing the user of the problem, use the list of env vars that
// glibc setlocale looks at. (LC_ALL is checked first, and LANG last.)
const char* const LocaleEnvVars[] = {
"LC_ALL",
"LC_COLLATE",
"LC_CTYPE",
"LC_MONETARY",
"LC_NUMERIC",
"LC_TIME",
"LC_MESSAGES",
"LANG"
};
try
{
// this constructor is similar to setlocale(LC_ALL, ""),
// but instead of returning NULL, it throws runtime_error
// when the first locale env variable found contains an invalid value
std::locale("");
}
catch (std::runtime_error&)
{
LOGWARNING("Invalid locale settings");
for (size_t i = 0; i < ARRAY_SIZE(LocaleEnvVars); i++)
{
if (char* envval = getenv(LocaleEnvVars[i]))
LOGWARNING(" %s=\"%s\"", LocaleEnvVars[i], envval);
else
LOGWARNING(" %s=\"(unset)\"", LocaleEnvVars[i]);
}
// We should set LC_ALL since it overrides LANG
if (setenv("LC_ALL", std::locale::classic().name().c_str(), 1))
debug_warn(L"Invalid locale settings, and unable to set LC_ALL env variable.");
else
LOGWARNING("Setting LC_ALL env variable to: %s", getenv("LC_ALL"));
}
}
#else
static void FixLocales()
{
// Do nothing on Windows
}
#endif
void EarlyInit()
{
// If you ever want to catch a particular allocation:
//_CrtSetBreakAlloc(232647);
Threading::SetMainThread();
debug_SetThreadName("main");
// add all debug_printf "tags" that we are interested in:
debug_filter_add("TIMER");
timer_Init();
// initialise profiler early so it can profile startup,
// but only after LatchStartTime
g_Profiler2.Initialise();
FixLocales();
// Because we do GL calls from a secondary thread, Xlib needs to
// be told to support multiple threads safely.
// This is needed for Atlas, but we have to call it before any other
// Xlib functions (e.g. the ones used when drawing the main menu
// before launching Atlas)
#if MUST_INIT_X11
int status = XInitThreads();
if (status == 0)
debug_printf("Error enabling thread-safety via XInitThreads\n");
#endif
// Initialise the low-quality rand function
srand(time(NULL)); // NOTE: this rand should *not* be used for simulation!
}
bool Autostart(const CmdLineArgs& args);
/**
* Returns true if the user has intended to start a visual replay from command line.
*/
bool AutostartVisualReplay(const std::string& replayFile);
bool Init(const CmdLineArgs& args, int flags)
{
h_mgr_init();
// Do this as soon as possible, because it chdirs
// and will mess up the error reporting if anything
// crashes before the working directory is set.
InitVfs(args, flags);
// This must come after VFS init, which sets the current directory
// (required for finding our output log files).
g_Logger = new CLogger;
new CProfileViewer;
new CProfileManager; // before any script code
g_ScriptStatsTable = new CScriptStatsTable;
g_ProfileViewer.AddRootTable(g_ScriptStatsTable);
// Set up the console early, so that debugging
// messages can be logged to it. (The console's size
// and fonts are set later in InitPs())
g_Console = new CConsole();
// g_ConfigDB, command line args, globals
CONFIG_Init(args);
// Using a global object for the context is a workaround until Simulation and AI use
// their own threads and also their own contexts.
const int contextSize = 384 * 1024 * 1024;
const int heapGrowthBytesGCTrigger = 20 * 1024 * 1024;
g_ScriptContext = ScriptContext::CreateContext(contextSize, heapGrowthBytesGCTrigger);
// On the first Init (INIT_MODS), check for command-line arguments
// or use the default mods from the config and enable those.
// On later engine restarts (e.g. the mod selector), we will skip this path,
// to avoid overwriting the newly selected mods.
if (flags & INIT_MODS)
{
ScriptInterface modInterface("Engine", "Mod", g_ScriptContext);
std::vector mods;
if (args.Has("mod"))
mods = args.GetMultiple("mod");
else
{
CStr modsStr;
CFG_GET_VAL("mod.enabledmods", modsStr);
boost::split(mods, modsStr, boost::algorithm::is_space(), boost::token_compress_on);
}
if (!g_Mods.EnableMods(modInterface, mods, flags & INIT_MODS_PUBLIC))
{
// In non-visual mode, fail entirely.
if (args.Has("autostart-nonvisual"))
{
LOGERROR("Trying to start with incompatible mods: %s.", boost::algorithm::join(g_Mods.GetIncompatibleMods(), ", "));
return false;
}
}
}
// If there are incompatible mods, switch to the mod selector so players can resolve the problem.
if (g_Mods.GetIncompatibleMods().empty())
MountMods(Paths(args), g_Mods.GetEnabledMods());
else
MountMods(Paths(args), { "mod" });
// Special command-line mode to dump the entity schemas instead of running the game.
// (This must be done after loading VFS etc, but should be done before wasting time
// on anything else.)
if (args.Has("dumpSchema"))
{
CSimulation2 sim(NULL, g_ScriptContext, NULL);
sim.LoadDefaultScripts();
std::ofstream f("entity.rng", std::ios_base::out | std::ios_base::trunc);
f << sim.GenerateSchema();
std::cout << "Generated entity.rng\n";
exit(0);
}
CNetHost::Initialize();
#if CONFIG2_AUDIO
if (!args.Has("autostart-nonvisual") && !g_DisableAudio)
ISoundManager::CreateSoundManager();
#endif
new L10n;
// Optionally start profiler HTTP output automatically
// (By default it's only enabled by a hotkey, for security/performance)
bool profilerHTTPEnable = false;
CFG_GET_VAL("profiler2.autoenable", profilerHTTPEnable);
if (profilerHTTPEnable)
g_Profiler2.EnableHTTP();
// Initialise everything except Win32 sockets (because our networking
// system already inits those)
curl_global_init(CURL_GLOBAL_ALL & ~CURL_GLOBAL_WIN32);
if (!g_Quickstart)
g_UserReporter.Initialize(); // after config
PROFILE2_EVENT("Init finished");
return true;
}
void InitGraphics(const CmdLineArgs& args, int flags, const std::vector& installedMods)
{
const bool setup_vmode = (flags & INIT_HAVE_VMODE) == 0;
if(setup_vmode)
{
InitSDL();
if (!g_VideoMode.InitSDL())
throw PSERROR_System_VmodeFailed(); // abort startup
}
RunHardwareDetection();
if (g_AtlasGameLoop && g_AtlasGameLoop->view)
SetTextureQuality(SANE_TEX_QUALITY_DEFAULT);
else
{
int textureQuality = SANE_TEX_QUALITY_DEFAULT;
CFG_GET_VAL("texturequality", textureQuality);
SetTextureQuality(textureQuality);
}
ogl_WarnIfError();
// Optionally start profiler GPU timings automatically
// (By default it's only enabled by a hotkey, for performance/compatibility)
bool profilerGPUEnable = false;
CFG_GET_VAL("profiler2.autoenable", profilerGPUEnable);
if (profilerGPUEnable)
g_Profiler2.EnableGPU();
if(!g_Quickstart)
{
WriteSystemInfo();
// note: no longer vfs_display here. it's dog-slow due to unbuffered
// file output and very rarely needed.
}
if(g_DisableAudio)
ISoundManager::SetEnabled(false);
g_GUI = new CGUIManager();
// (must come after SetVideoMode, since it calls ogl_Init)
CStr8 renderPath = "default";
CFG_GET_VAL("renderpath", renderPath);
if ((ogl_HaveExtensions(0, "GL_ARB_vertex_program", "GL_ARB_fragment_program", NULL) != 0 // ARB
&& ogl_HaveExtensions(0, "GL_ARB_vertex_shader", "GL_ARB_fragment_shader", NULL) != 0) // GLSL
|| !ogl_HaveExtension("GL_ARB_vertex_buffer_object") // VBO
|| RenderPathEnum::FromString(renderPath) == FIXED)
{
// It doesn't make sense to continue working here, because we're not
// able to display anything.
DEBUG_DISPLAY_FATAL_ERROR(
L"Your graphics card doesn't appear to be fully compatible with OpenGL shaders."
L" The game does not support pre-shader graphics cards."
L" You are advised to try installing newer drivers and/or upgrade your graphics card."
L" For more information, please see http://www.wildfiregames.com/forum/index.php?showtopic=16734"
);
}
const char* missing = ogl_HaveExtensions(0,
"GL_ARB_multitexture",
"GL_EXT_draw_range_elements",
"GL_ARB_texture_env_combine",
"GL_ARB_texture_env_dot3",
NULL);
if(missing)
{
wchar_t buf[500];
swprintf_s(buf, ARRAY_SIZE(buf),
L"The %hs extension doesn't appear to be available on your computer."
L" The game may still work, though - you are welcome to try at your own risk."
L" If not or it doesn't look right, upgrade your graphics card.",
missing
);
DEBUG_DISPLAY_ERROR(buf);
// TODO: i18n
}
if (!ogl_HaveExtension("GL_ARB_texture_env_crossbar"))
{
DEBUG_DISPLAY_ERROR(
L"The GL_ARB_texture_env_crossbar extension doesn't appear to be available on your computer."
L" Shadows are not available and overall graphics quality might suffer."
L" You are advised to try installing newer drivers and/or upgrade your graphics card.");
g_ConfigDB.SetValueBool(CFG_HWDETECT, "shadows", false);
}
ogl_WarnIfError();
g_RenderingOptions.ReadConfigAndSetupHooks();
InitRenderer();
InitInput();
ogl_WarnIfError();
// TODO: Is this the best place for this?
if (VfsDirectoryExists(L"maps/"))
CXeromyces::AddValidator(g_VFS, "map", "maps/scenario.rng");
try
{
if (!AutostartVisualReplay(args.Get("replay-visual")) && !Autostart(args))
{
const bool setup_gui = ((flags & INIT_NO_GUI) == 0);
// We only want to display the splash screen at startup
std::shared_ptr scriptInterface = g_GUI->GetScriptInterface();
ScriptRequest rq(scriptInterface);
JS::RootedValue data(rq.cx);
if (g_GUI)
{
Script::CreateObject(rq, &data, "isStartup", true);
if (!installedMods.empty())
Script::SetProperty(rq, data, "installedMods", installedMods);
}
InitPs(setup_gui, installedMods.empty() ? L"page_pregame.xml" : L"page_modmod.xml", g_GUI->GetScriptInterface().get(), data);
}
}
catch (PSERROR_Game_World_MapLoadFailed& e)
{
// Map Loading failed
// Start the engine so we have a GUI
InitPs(true, L"page_pregame.xml", NULL, JS::UndefinedHandleValue);
// Call script function to do the actual work
// (delete game data, switch GUI page, show error, etc.)
CancelLoad(CStr(e.what()).FromUTF8());
}
}
void InitNonVisual(const CmdLineArgs& args)
{
// Need some stuff for terrain movement costs:
// (TODO: this ought to be independent of any graphics code)
new CTerrainTextureManager;
g_TexMan.LoadTerrainTextures();
Autostart(args);
}
void RenderGui(bool RenderingState)
{
g_DoRenderGui = RenderingState;
}
void RenderLogger(bool RenderingState)
{
g_DoRenderLogger = RenderingState;
}
void RenderCursor(bool RenderingState)
{
g_DoRenderCursor = RenderingState;
}
/**
* Temporarily loads a scenario map and retrieves the "ScriptSettings" JSON
* data from it.
* The scenario map format is used for scenario and skirmish map types (random
* games do not use a "map" (format) but a small JavaScript program which
* creates a map on the fly). It contains a section to initialize the game
* setup screen.
* @param mapPath Absolute path (from VFS root) to the map file to peek in.
* @return ScriptSettings in JSON format extracted from the map.
*/
CStr8 LoadSettingsOfScenarioMap(const VfsPath &mapPath)
{
CXeromyces mapFile;
const char *pathToSettings[] =
{
"Scenario", "ScriptSettings", "" // Path to JSON data in map
};
Status loadResult = mapFile.Load(g_VFS, mapPath);
if (INFO::OK != loadResult)
{
LOGERROR("LoadSettingsOfScenarioMap: Unable to load map file '%s'", mapPath.string8());
throw PSERROR_Game_World_MapLoadFailed("Unable to load map file, check the path for typos.");
}
XMBElement mapElement = mapFile.GetRoot();
// Select the ScriptSettings node in the map file...
for (int i = 0; pathToSettings[i][0]; ++i)
{
int childId = mapFile.GetElementID(pathToSettings[i]);
XMBElementList nodes = mapElement.GetChildNodes();
auto it = std::find_if(nodes.begin(), nodes.end(), [&childId](const XMBElement& child) {
return child.GetNodeName() == childId;
});
if (it != nodes.end())
mapElement = *it;
}
// ... they contain a JSON document to initialize the game setup
// screen
return mapElement.GetText();
}
/*
* Command line options for autostart
* (keep synchronized with binaries/system/readme.txt):
*
* -autostart="TYPEDIR/MAPNAME" enables autostart and sets MAPNAME;
* TYPEDIR is skirmishes, scenarios, or random
* -autostart-seed=SEED sets randomization seed value (default 0, use -1 for random)
* -autostart-ai=PLAYER:AI sets the AI for PLAYER (e.g. 2:petra)
* -autostart-aidiff=PLAYER:DIFF sets the DIFFiculty of PLAYER's AI
* (0: sandbox, 5: very hard)
* -autostart-aiseed=AISEED sets the seed used for the AI random
* generator (default 0, use -1 for random)
* -autostart-player=NUMBER sets the playerID in non-networked games (default 1, use -1 for observer)
* -autostart-civ=PLAYER:CIV sets PLAYER's civilisation to CIV
* (skirmish and random maps only)
* -autostart-team=PLAYER:TEAM sets the team for PLAYER (e.g. 2:2).
* -autostart-ceasefire=NUM sets a ceasefire duration NUM
* (default 0 minutes)
* -autostart-nonvisual disable any graphics and sounds
* -autostart-victory=SCRIPTNAME sets the victory conditions with SCRIPTNAME
* located in simulation/data/settings/victory_conditions/
* (default conquest). When the first given SCRIPTNAME is
* "endless", no victory conditions will apply.
* -autostart-wonderduration=NUM sets the victory duration NUM for wonder victory condition
* (default 10 minutes)
* -autostart-relicduration=NUM sets the victory duration NUM for relic victory condition
* (default 10 minutes)
* -autostart-reliccount=NUM sets the number of relics for relic victory condition
* (default 2 relics)
* -autostart-disable-replay disable saving of replays
*
* Multiplayer:
* -autostart-playername=NAME sets local player NAME (default 'anonymous')
* -autostart-host sets multiplayer host mode
* -autostart-host-players=NUMBER sets NUMBER of human players for multiplayer
* game (default 2)
* -autostart-client=IP sets multiplayer client to join host at
* given IP address
* Random maps only:
* -autostart-size=TILES sets random map size in TILES (default 192)
* -autostart-players=NUMBER sets NUMBER of players on random map
* (default 2)
*
* Examples:
* 1) "Bob" will host a 2 player game on the Arcadia map:
* -autostart="scenarios/Arcadia" -autostart-host -autostart-host-players=2 -autostart-playername="Bob"
* "Alice" joins the match as player 2:
* -autostart="scenarios/Arcadia" -autostart-client=127.0.0.1 -autostart-playername="Alice"
* The players use the developer overlay to control players.
*
* 2) Load Alpine Lakes random map with random seed, 2 players (Athens and Britons), and player 2 is PetraBot:
* -autostart="random/alpine_lakes" -autostart-seed=-1 -autostart-players=2 -autostart-civ=1:athen -autostart-civ=2:brit -autostart-ai=2:petra
*
* 3) Observe the PetraBot on a triggerscript map:
* -autostart="random/jebel_barkal" -autostart-seed=-1 -autostart-players=2 -autostart-civ=1:athen -autostart-civ=2:brit -autostart-ai=1:petra -autostart-ai=2:petra -autostart-player=-1
*/
bool Autostart(const CmdLineArgs& args)
{
CStr autoStartName = args.Get("autostart");
if (autoStartName.empty())
return false;
g_Game = new CGame(!args.Has("autostart-disable-replay"));
ScriptInterface& scriptInterface = g_Game->GetSimulation2()->GetScriptInterface();
ScriptRequest rq(scriptInterface);
JS::RootedValue attrs(rq.cx);
JS::RootedValue settings(rq.cx);
JS::RootedValue playerData(rq.cx);
Script::CreateObject(rq, &attrs);
Script::CreateObject(rq, &settings);
Script::CreateArray(rq, &playerData);
// The directory in front of the actual map name indicates which type
// of map is being loaded. Drawback of this approach is the association
// of map types and folders is hard-coded, but benefits are:
// - No need to pass the map type via command line separately
// - Prevents mixing up of scenarios and skirmish maps to some degree
Path mapPath = Path(autoStartName);
std::wstring mapDirectory = mapPath.Parent().Filename().string();
std::string mapType;
if (mapDirectory == L"random")
{
// Random map definition will be loaded from JSON file, so we need to parse it
std::wstring scriptPath = L"maps/" + autoStartName.FromUTF8() + L".json";
JS::RootedValue scriptData(rq.cx);
Script::ReadJSONFile(rq, scriptPath, &scriptData);
if (!scriptData.isUndefined() && Script::GetProperty(rq, scriptData, "settings", &settings))
{
// JSON loaded ok - copy script name over to game attributes
std::wstring scriptFile;
- Script::GetProperty(rq, settings, "Script", scriptFile);
+ if (!Script::GetProperty(rq, settings, "Script", scriptFile))
+ {
+ LOGERROR("Autostart: random map '%s' data has no 'Script' property.", utf8_from_wstring(scriptPath));
+ throw PSERROR_Game_World_MapLoadFailed("Error reading random map script.\nCheck application log for details.");
+ }
Script::SetProperty(rq, attrs, "script", scriptFile); // RMS filename
}
else
{
// Problem with JSON file
LOGERROR("Autostart: Error reading random map script '%s'", utf8_from_wstring(scriptPath));
throw PSERROR_Game_World_MapLoadFailed("Error reading random map script.\nCheck application log for details.");
}
// Get optional map size argument (default 192)
uint mapSize = 192;
if (args.Has("autostart-size"))
{
CStr size = args.Get("autostart-size");
mapSize = size.ToUInt();
}
Script::SetProperty(rq, settings, "Size", mapSize); // Random map size (in patches)
// Get optional number of players (default 2)
size_t numPlayers = 2;
if (args.Has("autostart-players"))
{
CStr num = args.Get("autostart-players");
numPlayers = num.ToUInt();
}
// Set up player data
for (size_t i = 0; i < numPlayers; ++i)
{
JS::RootedValue player(rq.cx);
// We could load player_defaults.json here, but that would complicate the logic
// even more and autostart is only intended for developers anyway
Script::CreateObject(rq, &player, "Civ", "athen");
Script::SetPropertyInt(rq, playerData, i, player);
}
mapType = "random";
}
else if (mapDirectory == L"scenarios" || mapDirectory == L"skirmishes")
{
// Initialize general settings from the map data so some values
// (e.g. name of map) are always present, even when autostart is
// partially configured
CStr8 mapSettingsJSON = LoadSettingsOfScenarioMap("maps/" + autoStartName + ".xml");
Script::ParseJSON(rq, mapSettingsJSON, &settings);
// Initialize the playerData array being modified by autostart
// with the real map data, so sensible values are present:
Script::GetProperty(rq, settings, "PlayerData", &playerData);
if (mapDirectory == L"scenarios")
mapType = "scenario";
else
mapType = "skirmish";
}
else
{
LOGERROR("Autostart: Unrecognized map type '%s'", utf8_from_wstring(mapDirectory));
throw PSERROR_Game_World_MapLoadFailed("Unrecognized map type.\nConsult readme.txt for the currently supported types.");
}
Script::SetProperty(rq, attrs, "mapType", mapType);
Script::SetProperty(rq, attrs, "map", "maps/" + autoStartName);
Script::SetProperty(rq, settings, "mapType", mapType);
Script::SetProperty(rq, settings, "CheatsEnabled", true);
// The seed is used for both random map generation and simulation
u32 seed = 0;
if (args.Has("autostart-seed"))
{
CStr seedArg = args.Get("autostart-seed");
if (seedArg == "-1")
seed = rand();
else
seed = seedArg.ToULong();
}
Script::SetProperty(rq, settings, "Seed", seed);
// Set seed for AIs
u32 aiseed = 0;
if (args.Has("autostart-aiseed"))
{
CStr seedArg = args.Get("autostart-aiseed");
if (seedArg == "-1")
aiseed = rand();
else
aiseed = seedArg.ToULong();
}
Script::SetProperty(rq, settings, "AISeed", aiseed);
// Set player data for AIs
// attrs.settings = { PlayerData: [ { AI: ... }, ... ] }
// or = { PlayerData: [ null, { AI: ... }, ... ] } when gaia set
int offset = 1;
JS::RootedValue player(rq.cx);
if (Script::GetPropertyInt(rq, playerData, 0, &player) && player.isNull())
offset = 0;
// Set teams
if (args.Has("autostart-team"))
{
std::vector civArgs = args.GetMultiple("autostart-team");
for (size_t i = 0; i < civArgs.size(); ++i)
{
int playerID = civArgs[i].BeforeFirst(":").ToInt();
// Instead of overwriting existing player data, modify the array
JS::RootedValue currentPlayer(rq.cx);
if (!Script::GetPropertyInt(rq, playerData, playerID-offset, ¤tPlayer) || currentPlayer.isUndefined())
{
if (mapDirectory == L"skirmishes")
{
// playerID is certainly bigger than this map player number
LOGWARNING("Autostart: Invalid player %d in autostart-team option", playerID);
continue;
}
Script::CreateObject(rq, ¤tPlayer);
}
int teamID = civArgs[i].AfterFirst(":").ToInt() - 1;
Script::SetProperty(rq, currentPlayer, "Team", teamID);
Script::SetPropertyInt(rq, playerData, playerID-offset, currentPlayer);
}
}
int ceasefire = 0;
if (args.Has("autostart-ceasefire"))
ceasefire = args.Get("autostart-ceasefire").ToInt();
Script::SetProperty(rq, settings, "Ceasefire", ceasefire);
if (args.Has("autostart-ai"))
{
std::vector aiArgs = args.GetMultiple("autostart-ai");
for (size_t i = 0; i < aiArgs.size(); ++i)
{
int playerID = aiArgs[i].BeforeFirst(":").ToInt();
// Instead of overwriting existing player data, modify the array
JS::RootedValue currentPlayer(rq.cx);
if (!Script::GetPropertyInt(rq, playerData, playerID-offset, ¤tPlayer) || currentPlayer.isUndefined())
{
if (mapDirectory == L"scenarios" || mapDirectory == L"skirmishes")
{
// playerID is certainly bigger than this map player number
LOGWARNING("Autostart: Invalid player %d in autostart-ai option", playerID);
continue;
}
Script::CreateObject(rq, ¤tPlayer);
}
Script::SetProperty(rq, currentPlayer, "AI", aiArgs[i].AfterFirst(":"));
Script::SetProperty(rq, currentPlayer, "AIDiff", 3);
Script::SetProperty(rq, currentPlayer, "AIBehavior", "balanced");
Script::SetPropertyInt(rq, playerData, playerID-offset, currentPlayer);
}
}
// Set AI difficulty
if (args.Has("autostart-aidiff"))
{
std::vector civArgs = args.GetMultiple("autostart-aidiff");
for (size_t i = 0; i < civArgs.size(); ++i)
{
int playerID = civArgs[i].BeforeFirst(":").ToInt();
// Instead of overwriting existing player data, modify the array
JS::RootedValue currentPlayer(rq.cx);
if (!Script::GetPropertyInt(rq, playerData, playerID-offset, ¤tPlayer) || currentPlayer.isUndefined())
{
if (mapDirectory == L"scenarios" || mapDirectory == L"skirmishes")
{
// playerID is certainly bigger than this map player number
LOGWARNING("Autostart: Invalid player %d in autostart-aidiff option", playerID);
continue;
}
Script::CreateObject(rq, ¤tPlayer);
}
Script::SetProperty(rq, currentPlayer, "AIDiff", civArgs[i].AfterFirst(":").ToInt());
Script::SetPropertyInt(rq, playerData, playerID-offset, currentPlayer);
}
}
// Set player data for Civs
if (args.Has("autostart-civ"))
{
if (mapDirectory != L"scenarios")
{
std::vector civArgs = args.GetMultiple("autostart-civ");
for (size_t i = 0; i < civArgs.size(); ++i)
{
int playerID = civArgs[i].BeforeFirst(":").ToInt();
// Instead of overwriting existing player data, modify the array
JS::RootedValue currentPlayer(rq.cx);
if (!Script::GetPropertyInt(rq, playerData, playerID-offset, ¤tPlayer) || currentPlayer.isUndefined())
{
if (mapDirectory == L"skirmishes")
{
// playerID is certainly bigger than this map player number
LOGWARNING("Autostart: Invalid player %d in autostart-civ option", playerID);
continue;
}
Script::CreateObject(rq, ¤tPlayer);
}
Script::SetProperty(rq, currentPlayer, "Civ", civArgs[i].AfterFirst(":"));
Script::SetPropertyInt(rq, playerData, playerID-offset, currentPlayer);
}
}
else
LOGWARNING("Autostart: Option 'autostart-civ' is invalid for scenarios");
}
// Add player data to map settings
Script::SetProperty(rq, settings, "PlayerData", playerData);
// Add map settings to game attributes
Script::SetProperty(rq, attrs, "settings", settings);
// Get optional playername
CStrW userName = L"anonymous";
if (args.Has("autostart-playername"))
userName = args.Get("autostart-playername").FromUTF8();
// Add additional scripts to the TriggerScripts property
std::vector triggerScriptsVector;
JS::RootedValue triggerScripts(rq.cx);
if (Script::HasProperty(rq, settings, "TriggerScripts"))
{
Script::GetProperty(rq, settings, "TriggerScripts", &triggerScripts);
Script::FromJSVal(rq, triggerScripts, triggerScriptsVector);
}
if (!CRenderer::IsInitialised())
{
CStr nonVisualScript = "scripts/NonVisualTrigger.js";
triggerScriptsVector.push_back(nonVisualScript.FromUTF8());
}
std::vector victoryConditions(1, "conquest");
if (args.Has("autostart-victory"))
victoryConditions = args.GetMultiple("autostart-victory");
if (victoryConditions.size() == 1 && victoryConditions[0] == "endless")
victoryConditions.clear();
Script::SetProperty(rq, settings, "VictoryConditions", victoryConditions);
for (const CStr& victory : victoryConditions)
{
JS::RootedValue scriptData(rq.cx);
JS::RootedValue data(rq.cx);
JS::RootedValue victoryScripts(rq.cx);
CStrW scriptPath = L"simulation/data/settings/victory_conditions/" + victory.FromUTF8() + L".json";
Script::ReadJSONFile(rq, scriptPath, &scriptData);
if (!scriptData.isUndefined() && Script::GetProperty(rq, scriptData, "Data", &data) && !data.isUndefined()
&& Script::GetProperty(rq, data, "Scripts", &victoryScripts) && !victoryScripts.isUndefined())
{
std::vector victoryScriptsVector;
Script::FromJSVal(rq, victoryScripts, victoryScriptsVector);
triggerScriptsVector.insert(triggerScriptsVector.end(), victoryScriptsVector.begin(), victoryScriptsVector.end());
}
else
{
LOGERROR("Autostart: Error reading victory script '%s'", utf8_from_wstring(scriptPath));
throw PSERROR_Game_World_MapLoadFailed("Error reading victory script.\nCheck application log for details.");
}
}
Script::ToJSVal(rq, &triggerScripts, triggerScriptsVector);
Script::SetProperty(rq, settings, "TriggerScripts", triggerScripts);
int wonderDuration = 10;
if (args.Has("autostart-wonderduration"))
wonderDuration = args.Get("autostart-wonderduration").ToInt();
Script::SetProperty(rq, settings, "WonderDuration", wonderDuration);
int relicDuration = 10;
if (args.Has("autostart-relicduration"))
relicDuration = args.Get("autostart-relicduration").ToInt();
Script::SetProperty(rq, settings, "RelicDuration", relicDuration);
int relicCount = 2;
if (args.Has("autostart-reliccount"))
relicCount = args.Get("autostart-reliccount").ToInt();
Script::SetProperty(rq, settings, "RelicCount", relicCount);
if (args.Has("autostart-host"))
{
InitPsAutostart(true, attrs);
size_t maxPlayers = 2;
if (args.Has("autostart-host-players"))
maxPlayers = args.Get("autostart-host-players").ToUInt();
// Generate a secret to identify the host client.
std::string secret = ps_generate_guid();
g_NetServer = new CNetServer(false, maxPlayers);
g_NetServer->SetControllerSecret(secret);
g_NetServer->UpdateInitAttributes(&attrs, scriptInterface);
bool ok = g_NetServer->SetupConnection(PS_DEFAULT_PORT);
ENSURE(ok);
g_NetClient = new CNetClient(g_Game);
g_NetClient->SetUserName(userName);
g_NetClient->SetupServerData("127.0.0.1", PS_DEFAULT_PORT, false);
g_NetClient->SetControllerSecret(secret);
g_NetClient->SetupConnection(nullptr);
}
else if (args.Has("autostart-client"))
{
InitPsAutostart(true, attrs);
g_NetClient = new CNetClient(g_Game);
g_NetClient->SetUserName(userName);
CStr ip = args.Get("autostart-client");
if (ip.empty())
ip = "127.0.0.1";
g_NetClient->SetupServerData(ip, PS_DEFAULT_PORT, false);
ENSURE(g_NetClient->SetupConnection(nullptr));
}
else
{
g_Game->SetPlayerID(args.Has("autostart-player") ? args.Get("autostart-player").ToInt() : 1);
g_Game->StartGame(&attrs, "");
if (CRenderer::IsInitialised())
{
InitPsAutostart(false, attrs);
}
else
{
// TODO: Non progressive load can fail - need a decent way to handle this
LDR_NonprogressiveLoad();
ENSURE(g_Game->ReallyStartGame() == PSRETURN_OK);
}
}
return true;
}
bool AutostartVisualReplay(const std::string& replayFile)
{
if (!FileExists(OsPath(replayFile)))
return false;
g_Game = new CGame(false);
g_Game->SetPlayerID(-1);
g_Game->StartVisualReplay(replayFile);
ScriptInterface& scriptInterface = g_Game->GetSimulation2()->GetScriptInterface();
ScriptRequest rq(scriptInterface);
JS::RootedValue attrs(rq.cx, g_Game->GetSimulation2()->GetInitAttributes());
InitPsAutostart(false, attrs);
return true;
}
void CancelLoad(const CStrW& message)
{
std::shared_ptr pScriptInterface = g_GUI->GetActiveGUI()->GetScriptInterface();
ScriptRequest rq(pScriptInterface);
JS::RootedValue global(rq.cx, rq.globalValue());
LDR_Cancel();
if (g_GUI &&
g_GUI->GetPageCount() &&
Script::HasProperty(rq, global, "cancelOnLoadGameError"))
ScriptFunction::CallVoid(rq, global, "cancelOnLoadGameError", message);
}
bool InDevelopmentCopy()
{
if (!g_CheckedIfInDevelopmentCopy)
{
g_InDevelopmentCopy = (g_VFS->GetFileInfo(L"config/dev.cfg", NULL) == INFO::OK);
g_CheckedIfInDevelopmentCopy = true;
}
return g_InDevelopmentCopy;
}