Remove min/max mapsize constants from the rmgen library, refs #4034.

[0ad.git] / binaries / data / mods / public / maps / random / rmgen / library.js

const PI = Math.PI;
const TWO_PI = 2 * Math.PI;
const TERRAIN_SEPARATOR = "|";
const SEA_LEVEL = 20.0;
const CELL_SIZE = 4;
const HEIGHT_UNITS_PER_METRE = 92;
const MAP_BORDER_WIDTH = 3;
const FALLBACK_CIV = "athen";
/**
 * Constants needed for heightmap_manipulation.js
 */
const MAX_HEIGHT_RANGE = 0xFFFF / HEIGHT_UNITS_PER_METRE; // Engine limit, Roughly 700 meters
const MIN_HEIGHT = - SEA_LEVEL;
const MAX_HEIGHT = MAX_HEIGHT_RANGE - SEA_LEVEL;
// Default angle for buildings
const BUILDING_ORIENTATION = - PI / 4;

function fractionToTiles(f)
{
        return g_Map.size * f;
}

function tilesToFraction(t)
{
        return t / g_Map.size;
}

function fractionToSize(f)
{
        return getMapArea() * f;
}

function sizeToFraction(s)
{
        return s / getMapArea();
}

function scaleByMapSize(min, max, minMapSize = 128, maxMapSize = 512)
{
        return min + (max - min) * (g_Map.size - minMapSize) / (maxMapSize - minMapSize);
}

function cos(x)
{
        return Math.cos(x);
}

function sin(x)
{
        return Math.sin(x);
}

function abs(x) {
        return Math.abs(x);
}

function round(x)
{
        return Math.round(x);
}

function lerp(a, b, t)
{
        return a + (b-a) * t;
}

function sqrt(x)
{
        return Math.sqrt(x);
}

function ceil(x)
{
        return Math.ceil(x);
}

function floor(x)
{
        return Math.floor(x);
}

function max(a, b)
{
        return a > b ? a : b;
}

function min(a, b)
{
        return a < b ? a : b;
}

/**
 * Retries the given function with those arguments as often as specified.
 */
function retryPlacing(placeFunc, placeArgs, retryFactor, amount, getResult, behaveDeprecated = false)
{
        if (behaveDeprecated && !(placeArgs.placer instanceof SimpleGroup || placeArgs.placer instanceof RandomGroup))
                warn("Deprecated version of createFoo should only be used for SimpleGroup and RandomGroup placers!");

        let maxFail = amount * retryFactor;

        let results = [];
        let good = 0;
        let bad = 0;

        while (good < amount && bad <= maxFail)
        {
                let result = placeFunc(placeArgs);

                if (result !== undefined || behaveDeprecated)
                {
                        ++good;
                        if (getResult)
                                results.push(result);
                }
                else
                        ++bad;
        }
        return getResult ? results : good;
}

/**
 * Helper function for randomly placing areas and groups on the map.
 */
function randomizePlacerCoordinates(placer, halfMapSize)
{
        if (!!g_MapSettings.CircularMap)
        {
                // Polar coordinates
                // Uniformly distributed on the disk
                let r = halfMapSize * Math.sqrt(randFloat(0, 1));
                let theta = randFloat(0, 2 * PI);
                placer.x = Math.floor(r * Math.cos(theta)) + halfMapSize;
                placer.z = Math.floor(r * Math.sin(theta)) + halfMapSize;
        }
        else
        {
                // Rectangular coordinates
                placer.x = randIntExclusive(0, g_Map.size);
                placer.z = randIntExclusive(0, g_Map.size);
        }
}

/**
 * Helper function for randomly placing areas and groups in the given areas.
 */
function randomizePlacerCoordinatesFromAreas(placer, areas)
{
        let pt = pickRandom(pickRandom(areas).points);
        placer.x = pt.x;
        placer.z = pt.z;
}

// TODO this is a hack to simulate the old behaviour of those functions
// until all old maps are changed to use the correct version of these functions
function createObjectGroupsDeprecated(placer, player, constraint, amount, retryFactor = 10)
{
        return createObjectGroups(placer, player, constraint, amount, retryFactor, true);
}

function createObjectGroupsByAreasDeprecated(placer, player, constraint, amount, retryFactor, areas)
{
        return createObjectGroupsByAreas(placer, player, constraint, amount, retryFactor, areas, true);
}

/**
 * Attempts to place the given number of areas in random places of the map.
 * Returns actually placed areas.
 */
function createAreas(centeredPlacer, painter, constraint, amount, retryFactor = 10, behaveDeprecated = false)
{
        let placeFunc = function (args) {
                randomizePlacerCoordinates(args.placer, args.halfMapSize);
                return g_Map.createArea(args.placer, args.painter, args.constraint);
        };

        let args = {
                "placer": centeredPlacer,
                "painter": painter,
                "constraint": constraint,
                "halfMapSize": g_Map.size / 2
        };

        return retryPlacing(placeFunc, args, retryFactor, amount, true, behaveDeprecated);
}

/**
 * Attempts to place the given number of areas in random places of the given areas.
 * Returns actually placed areas.
 */
function createAreasInAreas(centeredPlacer, painter, constraint, amount, retryFactor, areas, behaveDeprecated = false)
{
        if (!areas.length)
                return [];

        let placeFunc = function (args) {
                randomizePlacerCoordinatesFromAreas(args.placer, args.areas);
                return g_Map.createArea(args.placer, args.painter, args.constraint);
        };

        let args = {
                "placer": centeredPlacer,
                "painter": painter,
                "constraint": constraint,
                "areas": areas,
                "halfMapSize": g_Map.size / 2
        };

        return retryPlacing(placeFunc, args, retryFactor, amount, true, behaveDeprecated);
}

/**
 * Attempts to place the given number of groups in random places of the map.
 * Returns the number of actually placed groups.
 */
function createObjectGroups(placer, player, constraint, amount, retryFactor = 10, behaveDeprecated = false)
{
        let placeFunc = function (args) {
                randomizePlacerCoordinates(args.placer, args.halfMapSize);
                return createObjectGroup(args.placer, args.player, args.constraint);
        };

        let args = {
                "placer": placer,
                "player": player,
                "constraint": constraint,
                "halfMapSize": getMapSize() / 2 - MAP_BORDER_WIDTH
        };

        return retryPlacing(placeFunc, args, retryFactor, amount, false, behaveDeprecated);
}

/**
 * Attempts to place the given number of groups in random places of the given areas.
 * Returns the number of actually placed groups.
 */
function createObjectGroupsByAreas(placer, player, constraint, amount, retryFactor, areas, behaveDeprecated = false)
{
        if (!areas.length)
                return 0;

        let placeFunc = function (args) {
                randomizePlacerCoordinatesFromAreas(args.placer, args.areas);
                return createObjectGroup(args.placer, args.player, args.constraint);
        };

        let args = {
                "placer": placer,
                "player": player,
                "constraint": constraint,
                "areas": areas
        };

        return retryPlacing(placeFunc, args, retryFactor, amount, false, behaveDeprecated);
}

function createTerrain(terrain)
{
        if (!(terrain instanceof Array))
                return createSimpleTerrain(terrain);

        return new RandomTerrain(terrain.map(t => createTerrain(t)));
}

function createSimpleTerrain(terrain)
{
        if (typeof(terrain) != "string")
                throw new Error("createSimpleTerrain expects string as input, received " + uneval(terrain));

        // Split string by pipe | character, this allows specifying terrain + tree type in single string
        let params = terrain.split(TERRAIN_SEPARATOR, 2);

        if (params.length != 2)
                return new SimpleTerrain(terrain);

        return new SimpleTerrain(params[0], params[1]);
}

function placeObject(x, z, type, player, angle)
{
        if (g_Map.validT(x, z))
                g_Map.addObject(new Entity(type, player, x, z, angle));
}

function placeTerrain(x, z, terrain)
{
        // convert terrain param into terrain object
        g_Map.placeTerrain(x, z, createTerrain(terrain));
}

function initTerrain(terrain)
{
        g_Map.initTerrain(createTerrain(terrain));
}

function isCircularMap()
{
        return !!g_MapSettings.CircularMap;
}

function getMapBaseHeight()
{
        return g_MapSettings.BaseHeight;
}

function createTileClass()
{
        return g_Map.createTileClass();
}

function getTileClass(id)
{
        if (!g_Map.validClass(id))
                return undefined;

        return g_Map.tileClasses[id];
}

function createArea(placer, painter, constraint)
{
        return g_Map.createArea(placer, painter, constraint);
}

function createObjectGroup(placer, player, constraint)
{
        return g_Map.createObjectGroup(placer, player, constraint);
}

function getMapSize()
{
        return g_Map.size;
}

function getMapArea()
{
        return g_Map.size * g_Map.size;
}

function getNumPlayers()
{
        return g_MapSettings.PlayerData.length - 1;
}

function getCivCode(player)
{
        if (g_MapSettings.PlayerData[player+1].Civ)
                return g_MapSettings.PlayerData[player+1].Civ;

        warn("undefined civ specified for player " + (player + 1) + ", falling back to '" + FALLBACK_CIV + "'");
        return FALLBACK_CIV;
}

function areAllies(player1, player2)
{
        if (g_MapSettings.PlayerData[player1+1].Team === undefined ||
                g_MapSettings.PlayerData[player2+1].Team === undefined ||
                g_MapSettings.PlayerData[player2+1].Team == -1 ||
                g_MapSettings.PlayerData[player1+1].Team == -1)
                return false;

        return g_MapSettings.PlayerData[player1+1].Team === g_MapSettings.PlayerData[player2+1].Team;
}

function getPlayerTeam(player)
{
        if (g_MapSettings.PlayerData[player+1].Team === undefined)
                return -1;

        return g_MapSettings.PlayerData[player+1].Team;
}

/**
 * Sorts an array of player IDs by team index. Players without teams come first.
 * Randomize order for players of the same team.
 */
function sortPlayers(playerIndices)
{
        return shuffleArray(playerIndices).sort((p1, p2) => getPlayerTeam(p1 - 1) - getPlayerTeam(p2 - 1));
}

/**
 * Mix player indices 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);
}

function primeSortPlayers(playerIndices)
{
        if (!playerIndices.length)
                return [];

        let prime = [];
        for (let i = 0; i < Math.ceil(playerIndices.length / 2); ++i)
        {
                prime.push(playerIndices[i]);
                prime.push(playerIndices[playerIndices.length - 1 - i]);
        }

        return prime;
}

function primeSortAllPlayers()
{
        return primeSortPlayers(sortAllPlayers());
}

function radialPlayerPlacement(percentRadius = 0.35)
{
        let playerIDs = sortAllPlayers();

        let playerX = [];
        let playerZ = [];
        let playerAngle = [];

        let startAngle = randFloat(0, TWO_PI);

        for (let i = 0; i < getNumPlayers(); ++i)
        {
                playerAngle[i] = startAngle + i * TWO_PI / getNumPlayers();
                playerX[i] = 0.5 + percentRadius * Math.cos(playerAngle[i]);
                playerZ[i] = 0.5 + percentRadius * Math.sin(playerAngle[i]);
        }

        return [playerIDs, playerX, playerZ, playerAngle, startAngle];
}

/**
 * Returns an array of percent numbers indicating the player location on river maps.
 * For example [0.2, 0.2, 0.4, 0.4, 0.6, 0.6, 0.8, 0.8] for a 4v4 or
 * [0.25, 0.33, 0.5, 0.67, 0.75] for a 2v3.
 */
function placePlayersRiver()
{
        let playerPos = [];
        let numPlayers = getNumPlayers();
        let numPlayersEven = numPlayers % 2 == 0;

        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;

                playerPos[i] = ((i - 1 + offsetDivident) / 2 + 1) / ((numPlayers + offsetDivisor) / 2 + 1);
        }

        return playerPos;
}

function getStartingEntities(player)
{
        let civ = getCivCode(player);

        if (!g_CivData[civ] || !g_CivData[civ].StartEntities || !g_CivData[civ].StartEntities.length)
        {
                warn("Invalid or unimplemented civ '"+civ+"' specified, falling back to '" + FALLBACK_CIV + "'");
                civ = FALLBACK_CIV;
        }

        return g_CivData[civ].StartEntities;
}

function getHeight(x, z)
{
        return g_Map.getHeight(x, z);
}

function setHeight(x, z, height)
{
        g_Map.setHeight(x, z, height);
}

/**
 *      Utility functions for classes
 */

/**
 * Add point to given class by id
 */
function addToClass(x, z, id)
{
        let tileClass = getTileClass(id);

        if (tileClass !== null)
                tileClass.add(x, z);
}

/**
 * Remove point from the given class by id
 */
function removeFromClass(x, z, id)
{
        let tileClass = getTileClass(id);

        if (tileClass !== null)
                tileClass.remove(x, z);
}

/**
 * Create a painter for the given class
 */
function paintClass(id)
{
        return new TileClassPainter(getTileClass(id));
}

/**
 * Create a painter for the given class
 */
function unPaintClass(id)
{
        return new TileClassUnPainter(getTileClass(id));
}

/**
 * Create an avoid constraint for the given classes by the given distances
 */
function avoidClasses(/*class1, dist1, class2, dist2, etc*/)
{
        let ar = [];
        for (let i = 0; i < arguments.length/2; ++i)
                ar.push(new AvoidTileClassConstraint(arguments[2*i], arguments[2*i+1]));

        // Return single constraint
        if (ar.length == 1)
                return ar[0];

        return new AndConstraint(ar);
}

/**
 * Create a stay constraint for the given classes by the given distances
 */
function stayClasses(/*class1, dist1, class2, dist2, etc*/)
{
        let ar = [];
        for (let i = 0; i < arguments.length/2; ++i)
                ar.push(new StayInTileClassConstraint(arguments[2*i], arguments[2*i+1]));

        // Return single constraint
        if (ar.length == 1)
                return ar[0];

        return new AndConstraint(ar);
}

/**
 * Create a border constraint for the given classes by the given distances
 */
function borderClasses(/*class1, idist1, odist1, class2, idist2, odist2, etc*/)
{
        let ar = [];
        for (let i = 0; i < arguments.length/3; ++i)
                ar.push(new BorderTileClassConstraint(arguments[3*i], arguments[3*i+1], arguments[3*i+2]));

        // Return single constraint
        if (ar.length == 1)
                return ar[0];

        return new AndConstraint(ar);
}

/**
 * Checks if the given tile is in class "id"
 */
function checkIfInClass(x, z, id)
{
        let tileClass = getTileClass(id);
        if (tileClass === null)
                return 0;

        let members = tileClass.countMembersInRadius(x, z, 1);
        if (members === null)
                return 0;

        return members;
}

/**
 * Returns the angle of the vector between point 1 and point 2.
 * The angle is counterclockwise from the positive x axis.
 */
function getAngle(x1, z1, x2, z2)
{
        return Math.atan2(z2 - z1, x2 - x1);
}

/**
 * Returns the gradient of the line between point 1 and 2 in the form dz/dx
 */
function getGradient(x1, z1, x2, z2)
{
        if (x1 == x2 && z1 == z2)
                return 0;

        return (z1-z2)/(x1-x2);
}

function getTerrainTexture(x, y)
{
        return g_Map.getTexture(x, y);
}

function addCivicCenterAreaToClass(ix, iz, tileClass)
{
        addToClass(ix, iz, tileClass);

        addToClass(ix, iz + 5, tileClass);
        addToClass(ix, iz - 5, tileClass);

        addToClass(ix + 5, iz, tileClass);
        addToClass(ix - 5, iz, tileClass);
}

/**
 * Returns the order to go through the points for the shortest closed path (array of indices)
 * @param {array} [points] - Points to be sorted of the form { "x": x_value, "y": y_value }
 */
function getOrderOfPointsForShortestClosePath(points)
{
        let order = [];
        let distances = [];
        if (points.length <= 3)
        {
                for (let i = 0; i < points.length; ++i)
                        order.push(i);

                return order;
        }

        // Just add the first 3 points
        let pointsToAdd = clone(points);
        for (let i = 0; i < 3; ++i)
        {
                order.push(i);
                pointsToAdd.shift(i);
                if (i)
                        distances.push(Math.euclidDistance2D(points[order[i]].x, points[order[i]].y, points[order[i - 1]].x, points[order[i - 1]].y));
        }

        distances.push(Math.euclidDistance2D(
                points[order[0]].x,
                points[order[0]].y,
                points[order[order.length - 1]].x,
                points[order[order.length - 1]].y));

        // Add remaining points so the path lengthens the least
        let numPointsToAdd = pointsToAdd.length;
        for (let i = 0; i < numPointsToAdd; ++i)
        {
                let indexToAddTo;
                let minEnlengthen = Infinity;
                let minDist1 = 0;
                let minDist2 = 0;
                for (let k = 0; k < order.length; ++k)
                {
                        let dist1 = Math.euclidDistance2D(pointsToAdd[0].x, pointsToAdd[0].y, points[order[k]].x, points[order[k]].y);
                        let dist2 = Math.euclidDistance2D(pointsToAdd[0].x, pointsToAdd[0].y, points[order[(k + 1) % order.length]].x, points[order[(k + 1) % order.length]].y);
                        let enlengthen = dist1 + dist2 - distances[k];
                        if (enlengthen < minEnlengthen)
                        {
                                indexToAddTo = k;
                                minEnlengthen = enlengthen;
                                minDist1 = dist1;
                                minDist2 = dist2;
                        }
                }
                order.splice(indexToAddTo + 1, 0, i + 3);
                distances.splice(indexToAddTo, 1, minDist1, minDist2);
                pointsToAdd.shift();
        }

        return order;
}