RMS_JS_Implementation.2.patch on Ticket #658 – Attachment – Wildfire Games

binaries/data/mods/public/gui/gamesetup/gamesetup.js

     // Init map types
     var mapTypes = getGUIObjectByName("mapTypeSelection");
     mapTypes.list = ["Scenario"];   // TODO: May offer saved game type for multiplayer games?
     mapTypes.list_data = ["scenario"];
+    mapTypes.list = ["Scenario", "Random"]; // TODO: May offer saved game type for multiplayer games?
+    mapTypes.list_data = ["scenario", "random"];
     // Setup controls for host only
     if (g_IsController)

binaries/data/mods/public/maps/mapgen/area.js


	1	function Area(points)
	2	{
	3	this.points = (points !== undefined ? points : []);
	4	}

binaries/data/mods/public/maps/mapgen/constraint.js

+///////////////////////////////////////////////////////////////////////////
+//  NullConstraints: No constraint - always return true
+///////////////////////////////////////////////////////////////////////////
+function NullConstraint() {}
+NullConstraint.prototype.allows = function(x, y)
+{
+    return true;
+};
+///////////////////////////////////////////////////////////////////////////
+//  AndConstraints: Check multiple constraints
+///////////////////////////////////////////////////////////////////////////
+function AndConstraint(constraints)
+{
+    this.constraints = constraints;
+}
+AndConstraint.prototype.allows = function(x, y)
+{
+    for (var i=0; i < this.constraints.length; ++i)
+    {
+        if (!this.constraints[i].allows(x, y))
+            return false;
+    }
+    return true;
+};
+///////////////////////////////////////////////////////////////////////////
+//  AvoidAreaConstraint
+///////////////////////////////////////////////////////////////////////////
+function AvoidAreaConstraint(area)
+{
+    this.area = area;
+}
+AvoidAreaConstraint.prototype.allows = function(x, y)
+{
+    return g_Map.area[x][y] != this.area;
+};
+///////////////////////////////////////////////////////////////////////////
+//  AvoidTextureConstraint
+///////////////////////////////////////////////////////////////////////////
+function AvoidTextureConstraint(textureID)
+{
+    this.textureID = textureID;
+}
+AvoidTextureConstraint.prototype.allows = function(x, y)
+{
+    return g_Map.texture[x][y] != this.textureID;
+};
+///////////////////////////////////////////////////////////////////////////
+//  AvoidTileClassConstraint
+///////////////////////////////////////////////////////////////////////////
+function AvoidTileClassConstraint(tileClassID, distance)
+{
+    this.tileClass = getTileClass(tileClassID);
+    this.distance = distance;
+}
+AvoidTileClassConstraint.prototype.allows = function(x, y)
+{
+    return this.tileClass.countMembersInRadius(x, y, this.distance) == 0;
+};
+///////////////////////////////////////////////////////////////////////////
+//  StayInTileClassConstraint
+///////////////////////////////////////////////////////////////////////////
+function StayInTileClassConstraint(tileClassID, distance)
+{
+    this.tileClass = getTileClass(tileClassID);
+    this.distance = distance;
+}
+StayInTileClassConstraint.prototype.allows = function(x, y)
+{
+    return this.tileClass.countNonMembersInRadius(x, y, this.distance) == 0;
+};
+///////////////////////////////////////////////////////////////////////////
+//  BorderTileClassConstraint
+///////////////////////////////////////////////////////////////////////////
+function BorderTileClassConstraint(tileClassID, distanceInside, distanceOutside)
+{
+    this.tileClass = getTileClass(tileClassID);
+    this.distanceInside = distanceInside;
+    this.distanceOutside = distanceOutside;
+}
+BorderTileClassConstraint.prototype.allows = function(x, y)
+{
+    return (this.tileClass.countMembersInRadius(x, y, this.distanceOutside) > 0
+        && this.tileClass.countNonMembersInRadius(x, y, this.distanceInside) > 0);
+};

binaries/data/mods/public/maps/mapgen/library.js

+// PI
+const PI = Math.PI;
+const SEA_LEVEL = 20.0;
+const TERRAIN_SEPARATOR = "|";
+const TILES_PER_PATCH = 16;
+/////////////////////////////////////////////////////////////////////////////////////////////
+//  Utility functions
+/////////////////////////////////////////////////////////////////////////////////////////////
+function fractionToTiles(f) {
+    return getMapSize() * f;
+}
+function tilesToFraction(t) {
+    return t / getMapSize();
+}
+function fractionToSize(f) {
+    return getMapSize() * getMapSize() * f;
+}
+function sizeToFraction(s) {
+    return s / getMapSize() / getMapSize();
+}
+function cos(x) {
+    return Math.cos(x);
+}
+function sin(x) {
+    return Math.sin(x);
+}
+function tan(x) {
+    return Math.tan(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(x, y) {
+    return x > y ? x : y;
+}
+function min(x, y) {
+    return x < y ? x : y;
+}
+function println(x) {
+    print(x);
+    print("\n");
+}
+function argsToArray(x) {
+    if (x.length!=1) {
+        var ret = new Array();
+        for (var i=0; i<x.length; i++) {
+            ret[i] = x[i];
+        }
+        return ret;
+    }
+    else {
+        return x[0];
+    }
+}
+function chooseRand() {
+    if (arguments.length==0) {
+        error("chooseRand: requires at least 1 argument");
+    }
+    var ar = argsToArray(arguments);
+    return ar[randInt(ar.length)];
+}
+function createAreas(centeredPlacer, painter, constraint, num, retryFactor)
+{
+    if (retryFactor === undefined)
+        retryFactor = 10;
+    var maxFail = num * retryFactor;
+    var good = 0;
+    var bad = 0;
+    var ret = [];
+    while(good < num && bad <= maxFail)
+    {
+        centeredPlacer.x = randInt(getMapSize());
+        centeredPlacer.y = randInt(getMapSize());
+        var r = g_Map.createArea(centeredPlacer, painter, constraint);
+        if (r !== undefined)
+        {
+            good++;
+            ret.push(r);
+        }
+        else
+        {
+            bad++;
+        }
+    }
+    return ret;
+}
+function createObjectGroups(placer, player, constraint, num, retryFactor)
+{
+    if (retryFactor === undefined)
+        retryFactor = 10;
+    var maxFail = num * retryFactor;
+    var good = 0;
+    var bad = 0;
+    while(good < num && bad <= maxFail)
+    {
+        placer.x = randInt(getMapSize());
+        placer.y = randInt(getMapSize());
+        var r = createObjectGroup(placer, player, constraint);
+        if (r !== undefined)
+        {
+            good++;
+        }
+        else
+        {
+            bad++;
+        }
+    }
+    return good;
+}
+function createTerrain(terrain)
+{
+    if (terrain instanceof Array)
+    {
+        var terrainList = [];
+        for (var i = 0; i < terrain.length; ++i)
+            terrainList.push(createTerrain(terrain[i]));
+        return new RandomTerrain(terrainList);
+    }
+    else
+    {
+        return createSimpleTerrain(terrain);
+    }
+}
+function createSimpleTerrain(terrain)
+{
+    if (typeof(terrain) == "string")
+    {   // Split string by pipe | character, this allows specifying terrain + tree type in single string
+        var params = terrain.split(TERRAIN_SEPARATOR, 2);
+        if (params.length != 2)
+        {
+            return new SimpleTerrain(terrain);
+        }
+        else
+        {
+            return new SimpleTerrain(params[0], params[1]);
+        }
+    }
+    else
+    {
+        error("createSimpleTerrain expects string as input, received "+terrain);
+        return undefined;
+    }
+}
+function placeObject(type, player, x, y, angle)
+{
+    g_Map.addObjects(new Entity(type, player, x, y, angle));
+}
+function placeTerrain(x, y, terrain)
+{
+    // convert terrain param into terrain object
+    g_Map.placeTerrain(x, y, createTerrain(terrain));
+}
+/////////////////////////////////////////////////////////////////////////////////////////////
+//  Access global map variable
+/////////////////////////////////////////////////////////////////////////////////////////////
+function createTileClass()
+{
+    return g_Map.createTileClass();
+}
+function getTileClass(id)
+{
+    // Check for valid class id
+    if (id < 1 || id > g_Map.tileClasses.length)
+    {
+        //error("Invalid tile class id: "+id);
+        return null;
+    }
+    return g_Map.tileClasses[id - 1];
+}
+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 getNumPlayers()
+{
+    return g_MapSettings.PlayerData.length;
+}
+function getCivCode(player)
+{
+    return g_MapSettings.PlayerData[player].Civ;
+}
+function getHeight(x, y)
+{
+    g_Map.getHeight(x, y);
+}
+function setHeight(x, y, height)
+{
+    g_Map.setHeight(x, y, height);
+}
+/////////////////////////////////////////////////////////////////////////////////////////////
+//  Utility functions for classes
+/////////////////////////////////////////////////////////////////////////////////////////////
+// Add point to given class by id
+function addToClass(x, y, id)
+{
+    var tileClass = getTileClass(id);
+    if (tileClass !== null)
+        tileClass.add(x, y);
+}
+// Create a painter for the given class
+function paintClass(id)
+{
+    return new TileClassPainter(getTileClass(id));
+}
+// Create an avoid constraint for the given classes by the given distances
+function avoidClasses(/*class1, dist1, class2, dist2, etc*/)
+{
+    var ar = new Array(arguments.length/2);
+    for (var i=0; i < arguments.length/2; i++)
+    {
+        ar[i] = new AvoidTileClassConstraint(arguments[2*i], arguments[2*i+1]);
+    }
+    // Return single constraint
+    return new AndConstraint(ar);
+}

binaries/data/mods/public/maps/mapgen/map.js

+//////////////////////////////////////////////////////////////////////
+//  Map
+//////////////////////////////////////////////////////////////////////
+function Map(size, baseHeight)
+{
+    // Size must be 0 to 1024, divisible by 16
+    this.size = size;
+    // Create 2D arrays for texture, object, and area maps
+    this.texture = new Array(size);
+    this.terrainObjects = new Array(size);
+    this.area = new Array(size);
+    for (var i=0; i < size; i++)
+    {
+        this.texture[i] = new Uint16Array(size);        // uint16
+        this.terrainObjects[i] = new Array(size);       // entity
+        this.area[i] = new Array(size);         // area
+        for (var j = 0; j < size; j++)
+        {
+            this.terrainObjects[i][j] = [];
+        }
+    }
+    var mapSize = size+1;
+    // Create 2D array for heightmap
+    this.height = new Array(mapSize);
+    for (var i=0; i < mapSize; i++)
+    {
+        this.height[i] = new Float32Array(mapSize);
+        for (var j=0; j < mapSize; j++)
+        {   // Initialize height map to baseHeight
+            this.height[i][j] = baseHeight;
+        }
+    }
+    // Create name <-> id maps for textures
+    this.nameToID = {};
+    this.IDToName = [];             //string
+    // Other arrays
+    this.objects = [];              //object
+    this.areas = [];                    //area
+    this.tileClasses = [];              //int
+    // Starting entity ID
+    this.entityCount = 150;
+}
+Map.prototype.initTerrain = function(baseTerrain)
+{
+    // Initialize base terrain
+    var size = this.size;
+    for (var i=0; i < size; i++)
+    {
+        for (var j=0; j < size; j++)
+        {
+            baseTerrain.place(i, j);
+        }
+    }
+};
+// Return ID of texture (by name)
+Map.prototype.getID = function(texture)
+{
+    if (texture in (this.nameToID))
+    {
+        return this.nameToID[texture];
+    }
+    // Add new texture
+    var id = this.IDToName.length;
+    this.nameToID[texture] = id;
+    this.IDToName[id] = texture;
+    return id;
+};
+// Return next free entity ID
+Map.prototype.getEntityID = function()
+{
+    return this.entityCount++;
+}
+// Check bounds
+Map.prototype.validT = function(x, y)
+{
+    return x >= 0 && y >= 0 && x < this.size && y < this.size;
+};
+// Check bounds on height map (size + 1 by size + 1)
+Map.prototype.validH = function(x, y)
+{
+    return x >= 0 && y >= 0 && x <= this.size && y <= this.size;
+};
+// Check bounds on tile class
+Map.prototype.validClass = function(c)
+{
+    return c >= 0 && c < this.tileClasses.length;
+};
+Map.prototype.getTexture = function(x, y)
+{
+    if (!this.validT(x, y))
+        error("getTexture: invalid tile position ("+x+", "+y+")");
+    return this.IDToName[this.texture[x][y]];
+};
+Map.prototype.setTexture = function(x, y, texture)
+{
+    if (!this.validT(x, y))
+        error("setTexture: invalid tile position ("+x+", "+y+")");
+     this.texture[x][y] = this.getID(texture);
+};
+Map.prototype.getHeight = function(x, y)
+{
+    if (!this.validH(x, y))
+        error("getHeight: invalid vertex position ("+x+", "+y+")");
+    return this.height[x][y];
+};
+Map.prototype.setHeight = function(x, y, height)
+{
+    if (!this.validH(x, y))
+        error("setHeight: invalid vertex position ("+x+", "+y+")");
+    this.height[x][y] = height;
+};
+Map.prototype.getTerrainObjects = function(x, y)
+{
+    if (!this.validT(x, y))
+        error("getTerrainObjects: invalid tile position ("+x+", "+y+")");
+    return this.terrainObjects[x][y];
+};
+Map.prototype.setTerrainObjects = function(x, y, objects)
+{
+    if (!this.validT(x, y))
+        error("setTerrainObjects: invalid tile position ("+x+", "+y+")");
+    this.terrainObjects[x][y] = objects;
+};
+Map.prototype.placeTerrain = function(x, y, terrain)
+{
+    terrain.place(x, y);
+};
+Map.prototype.addObjects = function(obj)
+{
+    this.objects = this.objects.concat(obj);
+};
+Map.prototype.createArea = function(placer, painter, constraint)
+{
+    // Check for multiple painters
+    if (painter instanceof Array)
+    {
+        var painterArray = painter;
+        painter = new MultiPainter(painterArray);
+    }
+    // Check for null constraint
+    if (constraint === undefined || constraint === null)
+    {
+        constraint = new NullConstraint();
+    }
+    else if (constraint instanceof Array)
+    {   // Check for multiple constraints
+        var constraintArray = constraint;
+        constraint = new AndConstraint(constraintArray);
+    }
+    var points = placer.place(constraint);
+    if (!points)
+        return undefined;
+    var a = new Area(points);
+    for (var i=0; i < points.length; i++)
+    {
+        this.area[points[i].x][points[i].y] = a;
+    }
+    painter.paint(a);
+    this.areas.push(a);
+    return a;
+};
+Map.prototype.createObjectGroup = function(placer, player, constraint)
+{
+    // Check for null constraint
+    if (constraint === undefined || constraint === null)
+    {
+        constraint = new NullConstraint();
+    }
+    else if (constraint instanceof Array)
+    {   // Check for multiple constraints
+        var constraintArray = constraint;
+        constraint = new AndConstraint(constraintArray);
+    }
+    return placer.place(player, constraint);
+};
+Map.prototype.createTileClass = function()
+{
+    this.tileClasses.push(new TileClass(this.size));
+    return this.tileClasses.length;
+};
+// Get height taking into account terrain curvature
+Map.prototype.getExactHeight = function(x, y)
+{
+    var xi = min(floor(x), this.size);
+    var yi = min(floor(y), this.size);
+    var xf = x - xi;
+    var yf = y - yi;
+    var h00 = this.height[xi][yi];
+    var h01 = this.height[xi][yi+1];
+    var h10 = this.height[xi+1][yi];
+    var h11 = this.height[xi+1][yi+1];
+    return ( 1 - yf ) * ( ( 1 - xf ) * h00 + xf * h10 ) + yf * ( ( 1 - xf ) * h01 + xf * h11 ) ;
+};
+Map.prototype.getMapData = function()
+{
+    var data = {};
+    // Build entity array
+    var entities = [];
+    // Terrain objects first (trees)
+    var size = this.size;
+    for (var x=0; x < size; ++x)
+    {
+        for (var y=0; y < size; ++y)
+        {
+            if (this.terrainObjects[x][y].length)
+                entities = entities.concat(this.terrainObjects[x][y]);
+        }
+    }
+    // Now other entities
+    for (var n in this.objects)
+    {
+        entities = entities.concat(this.objects[n]);
+    }
+    // Convert from tiles to map coordinates
+    for (var n in entities)
+    {
+        var e = entities[n];
+        e.x *= 4;
+        e.y *= 4;
+        entities[n] = e;
+    }
+    data["entities"] = entities;
+    // Terrain
+    data["size"] = this.size;
+    // Convert 2D heightmap array to flat array
+    //  Flat because it's easier to handle by the engine
+    var mapSize = size+1;
+    var height16 = new Array(mapSize*mapSize);      // uint16
+    for (var x=0; x < mapSize; x++)
+    {
+        for (var y=0; y < mapSize; y++)
+        {
+            var intHeight = ((this.height[x][y] + SEA_LEVEL) * 256.0 / 0.35)|0; // floor
+            if (intHeight > 65000)
+                intHeight = 65000;
+            else if (intHeight < 0)
+                intHeight = 0;
+            height16[y*mapSize + x] = intHeight;
+        }
+    }
+    data["height"] = height16;
+    data["seaLevel"] = SEA_LEVEL;
+    // Get array of textures used in this map
+    var textureNames = [];
+    for (var name in this.nameToID)
+        textureNames.push(name);
+    data["textureNames"] = textureNames;
+    data["numTextures"] = textureNames.length;
+    //  Convert 2D tile data to flat array, reodering into patches as expected by MapReader
+    var tiles = new Array(size*size);
+    var patches = size/16;
+    for (var x=0; x < size; x++)
+    {
+        var patchX = floor(x/16);
+        var offX = x%16;
+        for (var y=0; y < size; y++)
+        {
+            var patchY = floor(y/16);
+            var offY = y%16;
+            tiles[(patchY*patches + patchX)*256 + (offY*16 + offX)] = this.texture[x][y];
+        }
+    }
+    data["tileData"] = tiles;
+    return data;
+};

binaries/data/mods/public/maps/mapgen/mapgen.js

+// TODO: Since there's only one map anyway, just use this global variable
+var g_Map;
+// Map settings - once initialized, has all the game setup data, including player array
+var g_MapSettings = {
+    Size : 13,
+    Seed : 0,
+    BaseTerrain: "grass1_spring",
+    BaseHeight: 0,
+    PlayerData : [ {}, {} ]
+};
+var g_Environment = {
+    SkySet: "cirrus",
+    SunColour: {r: 1.47461, g: 1.47461, b: 1.47461},
+    SunElevation: 0.951868,
+    SunRotation: -0.532844,
+    TerrainAmbientColour: {r: 0.337255, g: 0.403922, b: 0.466667},
+    UnitsAmbientColour: {r: 0.501961, g: 0.501961, b: 0.501961},
+    Water: {
+        WaterBody: {
+            Type: "default",
+            Colour: {r: 0.294118, g: 0.34902, b: 0.694118},
+            Height: 17.6262,
+            Shininess: 150,
+            Waviness: 8,
+            Murkiness: 0.458008,
+            Tint: {r: 0.447059, g: 0.411765, b: 0.321569},
+            ReflectionTint: {r: 0.619608, g: 0.584314, b: 0.47451},
+            ReflectionTintStrength: 0.298828
+        }
+    }
+};
+var g_Camera = {
+    Position: {x: 100, y: 150, z: -100},
+    Rotation: 0,
+    Declination: 0.523599
+};
+function InitMapGen(settings)
+{
+    if (settings === undefined || settings == {})
+    {
+        warn("InitMapGen: settings missing");
+    }
+    else
+    {
+        g_MapSettings = settings;
+    }
+    // Init RNG with seed value
+    seedRand(g_MapSettings.Seed);
+    // Create new map
+    log("Creating new map...");
+    var terrain = createTerrain(g_MapSettings.BaseTerrain);
+    g_Map = new Map(g_MapSettings.Size * TILES_PER_PATCH, g_MapSettings.BaseHeight);
+    g_Map.initTerrain(terrain);
+}
+function SaveMap()
+{
+    log("Saving map...");
+    // Get necessary data from map
+    var data = g_Map.getMapData();
+    // Add environment and camera settings
+    g_Environment.Water.WaterBody.Height = SEA_LEVEL - 0.1;
+    data.Environment = g_Environment;
+    data.Camera = g_Camera;
+    return data;
+}

binaries/data/mods/public/maps/mapgen/noise.js

+// Utility function used in both noises as an ease curve
+function easeCurve(t)
+{
+    return t*t*t*(t*(t*6-15)+10);
+}
+// Find mod of number but only positive values
+function modPos(num, m)
+{
+    var p = num % m;
+    if (p < 0)
+        p += m;
+    return p;
+}
+/////////////////////////////////////////////////////////////////////
+//  Noise2D
+/////////////////////////////////////////////////////////////////////
+function Noise2D(freq)
+{
+    freq = floor(freq);
+    this.freq = freq;
+    this.grads = new Array(freq);
+    for (var i=0; i < freq; ++i)
+    {
+        this.grads[i] = new Array(freq);
+        for (var j=0; j < freq; ++j)
+        {
+            var a = randFloat() * 2 * PI;
+            this.grads[i][j] = new Vector2D(cos(a), sin(a));
+        }
+    }
+}
+Noise2D.prototype.get = function(x, y)
+{
+    x *= this.freq;
+    y *= this.freq;
+    var ix = modPos(floor(x), this.freq);
+    var iy = modPos(floor(y), this.freq);
+    var fx = x - ix;
+    var fy = y - iy;
+    var ix1 = (ix+1) % this.freq;
+    var iy1 = (iy+1) % this.freq;
+    var s = this.grads[ix][iy].dot(new Vector2D(fx, fy));
+    var t = this.grads[ix1][iy].dot(new Vector2D(fx-1, fy));
+    var u = this.grads[ix][iy1].dot(new Vector2D(fx, fy-1));
+    var v = this.grads[ix1][iy1].dot(new Vector2D(fx-1, fy-1));
+    var ex = easeCurve(fx);
+    var ey = easeCurve(fy);
+    var a = s + ex*(t-s);
+    var b = u + ex*(v-u);
+    return (a + ey*(b-a)) * 0.5 + 0.5;
+};
+/////////////////////////////////////////////////////////////////////
+//  Noise3D
+/////////////////////////////////////////////////////////////////////
+function Noise3D(freq, vfreq)
+{
+    freq = floor(freq);
+    vfreq = floor(vfreq);
+    this.freq = freq;
+    this.vfreq = vfreq;
+    this.grads = new Array(freq);
+    for (var i=0; i < freq; ++i)
+    {
+        this.grads[i] = new Array(freq);
+        for (var j=0; j < freq; ++j)
+        {
+            this.grads[i][j] = new Array(vfreq);
+            for(var k=0; k < vfreq; ++k)
+            {
+                var v = new Vector3D();
+                do
+                {
+                    v.set(2*randFloat()-1, 2*randFloat()-1, 2*randFloat()-1);
+                }
+                while(v.lengthSquared() > 1 || v.lengthSquared() < 0.1);
+                v.normalize();
+                this.grads[i][j][k] = v;
+            }
+        }
+    }
+}
+Noise3D.prototype.get = function(x, y, z)
+{
+    x *= this.freq;
+    y *= this.freq;
+    z *= this.vfreq;
+    var ix =modPos(floor(x), this.freq);
+    var iy = modPos(floor(y), this.freq);
+    var iz = modPos(floor(z), this.vfreq);
+    var fx = x - ix;
+    var fy = y - iy;
+    var fz = z - iz;
+    var ix1 = (ix+1) % this.freq;
+    var iy1 = (iy+1) % this.freq;
+    var iz1 = (iz+1) % this.vfreq;
+    var s0 = this.grads[ix][iy][iz].dot(new Vector3D(fx, fy, fz));
+    var t0 = this.grads[ix1][iy][iz].dot(new Vector3D(fx-1, fy, fz));
+    var u0 = this.grads[ix][iy1][iz].dot(new Vector3D(fx, fy-1, fz));
+    var v0 = this.grads[ix1][iy1][iz].dot(new Vector3D(fx-1, fy-1, fz));
+    var s1 = this.grads[ix][iy][iz1].dot(new Vector3D(fx, fy, fz-1));
+    var t1 = this.grads[ix1][iy][iz1].dot(new Vector3D(fx-1, fy, fz-1));
+    var u1 = this.grads[ix][iy1][iz1].dot(new Vector3D(fx, fy-1, fz-1));
+    var v1 = this.grads[ix1][iy1][iz1].dot(new Vector3D(fx-1, fy-1, fz-1));
+    var ex = easeCurve(fx);
+    var ey = easeCurve(fy);
+    var ez = easeCurve(fz);
+    var a0 = s0 + ex*(t0-s0);
+    var b0 = u0 + ex*(v0-u0);
+    var c0 = a0 + ey*(b0-a0);
+    var a1 = s1 + ex*(t1-s1);
+    var b1 = u1 + ex*(v1-u1);
+    var c1 = a1 + ey*(b1-a1);
+    return (c0 + ez*(c1-c0)) * 0.5 + 0.5;
+};

binaries/data/mods/public/maps/mapgen/painter.js

+const ELEVATION_SET = 0;
+const ELEVATION_MODIFY = 1;
+/////////////////////////////////////////////////////////////////////////////
+//  ElevationPainter
+/////////////////////////////////////////////////////////////////////////////
+function ElevationPainter(elevation)
+{
+    this.elevation = elevation;
+    this.DX = [0, 1, 1, 0];
+    this.DY = [0, 0, 1, 1];
+}
+ElevationPainter.prototype.paint = function(area)
+{
+    var length = area.points.length;
+    var elevation = this.elevation;
+    for (var i=0; i < length; i++)
+    {
+        var pt = area.points[i];
+        for (var j=0; j < 4; j++)
+        {
+            g_Map.height[pt.x+this.DX[j]][pt.y+this.DY[j]] = elevation;
+        }
+    }
+};
+/////////////////////////////////////////////////////////////////////////////
+//  LayeredPainter
+/////////////////////////////////////////////////////////////////////////////
+function LayeredPainter(terrainArray, widths)
+{
+    if (!(terrainArray instanceof Array))
+        error("terrains must be an array!");
+    this.terrains = [];
+    for (var i = 0; i < terrainArray.length; ++i)
+        this.terrains.push(createTerrain(terrainArray[i]));
+    this.widths = widths;
+}
+LayeredPainter.prototype.paint = function(area)
+{
+    var size = getMapSize();
+    var saw = new Array(size);
+    var dist = new Array(size);
+    // init typed arrays
+    for (var i = 0; i < size; ++i)
+    {
+        saw[i] = new Uint8Array(size);      // bool / uint8
+        dist[i] = new Uint16Array(size);        // uint16
+    }
+    // Point queue (implemented with array)
+    var pointQ = [];
+    // push edge points
+    var pts = area.points;
+    var length = pts.length;
+    for (var i=0; i < length; i++)
+    {
+        var x = pts[i].x;
+        var y = pts[i].y;
+        for (var dx=-1; dx <= 1; dx++)
+        {
+            var nx = x+dx;
+            for (var dy=-1; dy <= 1; dy++)
+            {
+                var ny = y+dy;
+                if (g_Map.validT(nx, ny) && g_Map.area[nx][ny] && g_Map.area[nx][ny] != area && !saw[nx][ny])
+                {
+                    saw[nx][ny] = 1;
+                    dist[nx][ny] = 0;
+                    pointQ.push(new Point(nx, ny));
+                }
+            }
+        }
+    }
+    // do BFS inwards to find distances to edge
+    while (pointQ.length)
+    {
+        var pt = pointQ.shift();    // Pop queue
+        var px = pt.x;
+        var py = pt.y;
+        var d = dist[px][py];
+        // paint if in area
+        if (g_Map.area[px][py] == area)
+        {
+            var w=0;
+            var i=0;
+            //~ while (i < this.widths.length && w < d)
+            //~ {
+                //~ w += this.widths[i];
+                //~ ++i;
+            //~ }
+            for (; i < this.widths.length; i++)
+            {
+                w += this.widths[i];
+                if (w >= d)
+                {
+                    break;
+                }
+            }
+            this.terrains[i].place(px, py);
+        }
+        // enqueue neighbours
+        for (var dx=-1; dx<=1; dx++)
+        {
+            var nx = px+dx;
+            for (var dy=-1; dy<=1; dy++)
+            {
+                var ny = py+dy;
+                if (g_Map.validT(nx, ny) && g_Map.area[nx][ny] && g_Map.area[nx][ny] == area && !saw[nx][ny])
+                {
+                    saw[nx][ny] = 1;
+                    dist[nx][ny] = d+1;
+                    pointQ.push(new Point(nx, ny));
+                }
+            }
+        }
+    }
+};
+/////////////////////////////////////////////////////////////////////////////
+//  MultiPainter
+/////////////////////////////////////////////////////////////////////////////
+function MultiPainter(painters)
+{
+    this.painters = painters;
+}
+MultiPainter.prototype.paint = function(area)
+{
+    for (var i=0; i < this.painters.length; i++)
+    {
+        this.painters[i].paint(area);
+    }
+};
+/////////////////////////////////////////////////////////////////////////////
+//  SmoothElevationPainter
+/////////////////////////////////////////////////////////////////////////////
+function SmoothElevationPainter(type, elevation, blendRadius)
+{
+    this.type = type;
+    this.elevation = elevation;
+    this.blendRadius = blendRadius;
+    if (type != ELEVATION_SET && type != ELEVATION_MODIFY)
+        error("SmoothElevationPainter: invalid type '"+type+"'");
+}
+SmoothElevationPainter.prototype.checkInArea = function(area, x, y)
+{
+    if (g_Map.validT(x, y))
+    {
+        return (g_Map.area[x][y] && g_Map.area[x][y] == area);
+    }
+    else
+    {
+        return false;
+    }
+};
+SmoothElevationPainter.prototype.paint = function(area)
+{
+    var pointQ = [];
+    var pts = area.points;
+    var heightPts = [];
+    var mapSize = getMapSize()+1;
+    var saw = new  Array(mapSize);
+    var dist = new Array(mapSize);
+    var gotHeightPt = new Array(mapSize);
+    var newHeight = new Array(mapSize);
+    // init typed arrays
+    for (var i = 0; i < mapSize; ++i)
+    {
+        saw[i] = new Uint8Array(mapSize);       // bool / uint8
+        dist[i] = new Uint16Array(mapSize);     // uint16
+        gotHeightPt[i] = new Uint8Array(mapSize);   // bool / uint8
+        newHeight[i] = new Float32Array(mapSize);   // float32
+    }
+    var length = pts.length;
+    // get a list of all points
+    for (var i=0; i < length; i++)
+    {
+        var x = pts[i].x;
+        var y = pts[i].y;
+        for (var dx=-1; dx <= 2; dx++)
+        {
+            var nx = x+dx;
+            for (var dy=-1; dy <= 2; dy++)
+            {
+                var ny = y+dy;
+                if (g_Map.validH(nx, ny) && !gotHeightPt[nx][ny])
+                {
+                    gotHeightPt[nx][ny] = 1;
+                    heightPts.push(new Point(nx, ny));
+                    newHeight[nx][ny] = g_Map.height[nx][ny];
+                }
+            }
+        }
+    }
+    // push edge points
+    for (var i=0; i < length; i++)
+    {
+        var x = pts[i].x, y = pts[i].y;
+        for (var dx=-1; dx <= 2; dx++)
+        {
+            var nx = x+dx;
+            for (var dy=-1; dy <= 2; dy++)
+            {
+                var ny = y+dy;
+                if (g_Map.validH(nx, ny)
+                    && !this.checkInArea(area, nx, ny)
+                    && !this.checkInArea(area, nx-1, ny)
+                    && !this.checkInArea(area, nx, ny-1)
+                    && !this.checkInArea(area, nx-1, ny-1)
+                    && !saw[nx][ny])
+                {
+                    saw[nx][ny]= 1;
+                    dist[nx][ny] = 0;
+                    pointQ.push(new Point(nx, ny));
+                }
+            }
+        }
+    }
+    // do BFS inwards to find distances to edge
+    while(pointQ.length)
+    {
+        var pt = pointQ.shift();
+        var px = pt.x;
+        var py = pt.y;
+        var d = dist[px][py];
+        // paint if in area
+        if (g_Map.validH(px, py)
+            && (this.checkInArea(area, px, py) || this.checkInArea(area, px-1, py)
+            || this.checkInArea(area, px, py-1) || this.checkInArea(area, px-1, py-1)))
+        {
+            if (d <= this.blendRadius)
+            {
+                var a = (d-1) / this.blendRadius;
+                if (this.type == ELEVATION_SET)
+                {
+                    newHeight[px][py] = a*this.elevation + (1-a)*g_Map.height[px][py];
+                }
+                else
+                {   // type == MODIFY
+                    newHeight[px][py] += a*this.elevation;
+                }
+            }
+            else
+            {   // also happens when blendRadius == 0
+                if (this.type == ELEVATION_SET)
+                {
+                    newHeight[px][py] = this.elevation;
+                }
+                else
+                {   // type == MODIFY
+                    newHeight[px][py] += this.elevation;
+                }
+            }
+        }
+        // enqueue neighbours
+        for (var dx=-1; dx <= 1; dx++)
+        {
+            var nx = px+dx;
+            for (var dy=-1; dy <= 1; dy++)
+            {
+                var ny = py+dy;
+                if (g_Map.validH(nx, ny)
+                    && (this.checkInArea(area, nx, ny) || this.checkInArea(area, nx-1, ny)
+                        || this.checkInArea(area, nx, ny-1) || this.checkInArea(area, nx-1, ny-1))
+                    && !saw[nx][ny])
+                {
+                    saw[nx][ny] = 1;
+                    dist[nx][ny] = d+1;
+                    pointQ.push(new Point(nx, ny));
+                }
+            }
+        }
+    }
+    length = heightPts.length;
+    // smooth everything out
+    for (var i = 0; i < length; ++i)
+    {
+        var pt = heightPts[i];
+        var px = pt.x;
+        var py = pt.y;
+        if ((this.checkInArea(area, px, py) || this.checkInArea(area, px-1, py)
+            || this.checkInArea(area, px, py-1) || this.checkInArea(area, px-1, py-1)))
+        {
+            var sum = 8 * newHeight[px][py];
+            var count = 8;
+            for (var dx=-1; dx <= 1; dx++)
+            {
+                var nx = px+dx;
+                for (var dy=-1; dy <= 1; dy++)
+                {
+                    var ny = py+dy;
+                    if (g_Map.validH(nx, ny))
+                    {
+                        sum += newHeight[nx][ny];
+                        count++;
+                    }
+                }
+            }
+            g_Map.height[px][py] = sum/count;
+        }
+    }
+};
+/////////////////////////////////////////////////////////////////////////////
+//  TerrainPainter
+/////////////////////////////////////////////////////////////////////////////
+function TerrainPainter(terrain)
+{
+    this.terrain = createTerrain(terrain);
+}
+TerrainPainter.prototype.paint = function(area)
+{
+    var length = area.points.length;
+    for (var i=0; i < length; i++)
+    {
+        var pt = area.points[i];
+        this.terrain.place(pt.x, pt.y);
+    }
+};
+/////////////////////////////////////////////////////////////////////////////
+//  TileClassPainter
+/////////////////////////////////////////////////////////////////////////////
+function TileClassPainter(tileClass)
+{
+    this.tileClass = tileClass;
+}
+TileClassPainter.prototype.paint = function(area)
+{
+    var length = area.points.length;
+    for (var i=0; i < length; i++)
+    {
+        var pt = area.points[i];
+        this.tileClass.add(pt.x, pt.y);
+    }
+};

binaries/data/mods/public/maps/mapgen/placer.js

+/////////////////////////////////////////////////////////////////////////////////////////
+//  ClumpPlacer
+/////////////////////////////////////////////////////////////////////////////////////////
+function ClumpPlacer(size, coherence, smoothness, failFraction, x, y)
+{
+    this.size = size;
+    this.coherence = coherence;
+    this.smoothness = smoothness;
+    this.failFraction = (failFraction !== undefined ? failFraction : 0);
+    this.x = (x !== undefined ? x : -1);
+    this.y = (y !== undefined ? y : -1);
+}
+ClumpPlacer.prototype.place = function(constraint)
+{
+    if (!g_Map.validT(this.x, this.y) || !constraint.allows(this.x, this.y))
+    {
+        return false;
+    }
+    var retVec = [];
+    var size = getMapSize();
+    var gotRet = new Array(size);
+    for (var i = 0; i < size; ++i)
+    {
+        gotRet[i] = new Uint8Array(size);       // bool / uint8
+    }
+    var radius = sqrt(this.size / PI);
+    var perim = 4 * radius * 2 * PI;
+    var intPerim = ceil(perim);
+    var ctrlPts = 1 + Math.floor(1.0/Math.max(this.smoothness,1.0/intPerim));
+    if (ctrlPts > radius * 2 * PI)
+        ctrlPts = Math.floor(radius * 2 * PI) + 1;
+    var noise = new Float32Array(intPerim);     //float32
+    var ctrlCoords = new Float32Array(ctrlPts+1);   //float32
+    var ctrlVals = new Float32Array(ctrlPts+1); //float32
+    for (var i=0; i < ctrlPts; i++)
+    {
+        ctrlCoords[i] = i * perim / ctrlPts;
+        ctrlVals[i] = 2.0*randFloat();
+    }
+    var c = 0;
+    var looped = 0;
+    for (var i=0; i < intPerim; i++)
+    {
+        if (ctrlCoords[(c+1) % ctrlPts] < i && !looped)
+        {
+            c = (c+1) % ctrlPts;
+            if (c==ctrlPts-1)
+                looped = 1;
+        }
+        var t = (i - ctrlCoords[c]) / ((looped ? perim : ctrlCoords[(c+1)%ctrlPts]) - ctrlCoords[c]);
+        var v0 = ctrlVals[(c+ctrlPts-1)%ctrlPts];
+        var v1 = ctrlVals[c];
+        var v2 = ctrlVals[(c+1)%ctrlPts];
+        var v3 = ctrlVals[(c+2)%ctrlPts];
+        var P = (v3 - v2) - (v0 - v1);
+        var Q = (v0 - v1) - P;
+        var R = v2 - v0;
+        var S = v1;
+        noise[i] = P*t*t*t + Q*t*t + R*t + S;
+    }
+    var failed = 0;
+    for (var p=0; p < intPerim; p++)
+    {
+        var th = 2 * PI * p / perim;
+        var r = radius * (1 + (1-this.coherence)*noise[p]);
+        var s = sin(th);
+        var c = cos(th);
+        var xx=this.x;
+        var yy=this.y;
+        for (var k=0; k < r; k++)
+        {
+            var i = Math.floor(xx);
+            var j = Math.floor(yy);
+            if (g_Map.validT(i, j) && constraint.allows(i, j))
+            {
+                if (!gotRet[i][j])
+                {   // Only include each point once
+                    gotRet[i][j] = 1;
+                    retVec.push(new Point(i, j));
+                }
+            }
+            else
+            {
+                failed++;
+            }
+            xx += s;
+            yy += c;
+        }
+    }
+    return ((failed > this.size*this.failFraction) ? undefined : retVec);
+};
+/////////////////////////////////////////////////////////////////////////////////////////
+//  RectPlacer
+/////////////////////////////////////////////////////////////////////////////////////////
+function RectPlacer(x1, y1, x2, y2)
+{
+    this.x1 = x1;
+    this.y1 = y1;
+    this.x2 = x2;
+    this.y2 = y2;
+    if (x1 > x2 || y1 > y2)
+        error("RectPlacer: incorrect bounds on rect");
+}
+RectPlacer.prototype.place = function(constraint)
+{
+    var ret = [];
+    var x2 = this.x2;
+    var y2 = this.y2;
+    for (var x=this.x1; x < x2; x++)
+    {
+        for (var y=this.y1; y < y2; y++)
+        {
+            if (g_Map.validT(x, y) && constraint.allows(x, y))
+            {
+                ret.push(new Point(x, y));
+            }
+            else
+            {
+                return undefined;
+            }
+        }
+    }
+    return ret;
+};
+/////////////////////////////////////////////////////////////////////////////////////////
+//  ObjectGroupPlacer
+/////////////////////////////////////////////////////////////////////////////////////////
+function ObjectGroupPlacer() {}
+/////////////////////////////////////////////////////////////////////////////////////////
+//  SimpleGroup
+/////////////////////////////////////////////////////////////////////////////////////////
+function SimpleObject(type, minCount, maxCount, minDistance, maxDistance, minAngle, maxAngle)
+{
+    this.type = type;
+    this.minCount = minCount;
+    this.maxCount = maxCount;
+    this.minDistance = minDistance;
+    this.maxDistance = maxDistance;
+    this.minAngle = (minAngle !== undefined ? minAngle : 0);
+    this.maxAngle = (maxAngle !== undefined ? maxAngle : 2*PI);
+    if (minCount > maxCount)
+        error("SimpleObject: minCount must be less than or equal to maxCount");
+    if (minDistance > maxDistance)
+        error("SimpleObject: minDistance must be less than or equal to maxDistance");
+    if (minAngle > maxAngle)
+        error("SimpleObject: minAngle must be less than or equal to maxAngle");
+}
+SimpleObject.prototype.place = function(cx, cy, player, avoidSelf, constraint)
+{
+    var failCount = 0;
+    var count = randInt(this.minCount, this.maxCount);
+    var resultObjs = [];
+    for (var i=0; i < count; i++)
+    {
+        while(true)
+        {
+            var distance = randFloat(this.minDistance, this.maxDistance);
+            var direction = randFloat(0, 2*PI);
+            var x = cx + 0.5 + distance*cos(direction);
+            var y = cy + 0.5 + distance*sin(direction);
+            var fail = false; // reset place failure flag
+            if (x < 0 || y < 0 || x > g_Map.size || y > g_Map.size)
+            {
+                fail = true;
+            }
+            else
+            {
+                if (avoidSelf)
+                {
+                    var length = resultObjs.length;
+                    for (var i = 0; (i < length) && !fail; i++)
+                    {
+                        var dx = x - resultObjs[i].x;
+                        var dy = y - resultObjs[i].y;
+                        if ((dx*dx + dy*dy) < 1)
+                        {
+                            fail = true;
+                        }
+                    }
+                }
+                if (!fail)
+                {
+                    if (!constraint.allows(Math.floor(x), Math.floor(y)))
+                    {
+                        fail = true;
+                    }
+                    else
+                    {   // if we got here, we're good
+                        var angle = randFloat(this.minAngle, this.maxAngle);
+                        resultObjs.push(new Entity(this.type, player, x, y, angle));
+                        break;
+                    }
+                }
+            }
+            if (fail)
+            {
+                failCount++;
+                if (failCount > 20) // TODO: Make this adjustable
+                {
+                    return undefined;
+                }
+            }
+        }
+    }
+    return resultObjs;
+};
+function SimpleGroup(elements, avoidSelf, tileClass, x, y)
+{
+    this.elements = elements;
+    this.tileClass = (tileClass !== undefined ? getTileClass(tileClass) : null);
+    this.avoidSelf = (avoidSelf !== undefined ? avoidSelf : false);
+    this.x = (x !== undefined ? x : -1);
+    this.y = (y !== undefined ? y : -1);
+}
+SimpleGroup.prototype.place = function(player, constraint)
+{
+    var resultObjs = [];
+    // Try placement of objects
+    var length = this.elements.length;
+    for (var i=0; i < length; i++)
+    {
+        var objs = this.elements[i].place(this.x, this.y, player, this.avoidSelf, constraint);
+        if (objs === undefined)
+        {   // Failure
+            return false;
+        }
+        else
+        {
+            resultObjs = resultObjs.concat(objs);
+        }
+    }
+    // Add placed objects to map
+    length = resultObjs.length;
+    for (var i=0; i < length; i++)
+    {
+        g_Map.addObjects(resultObjs[i]);
+        if (this.tileClass !== null)
+        {   // Round object position to integer
+            this.tileClass.add(Math.floor(resultObjs[i].x), Math.floor(resultObjs[i].y));
+        }
+    }
+    return true;
+};

binaries/data/mods/public/maps/mapgen/point.js


	1	function Point(x, y)
	2	{
	3	this.x = (x !== undefined ? x : 0);
	4	this.y = (y !== undefined ? y : 0);
	5	}

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

+//~ function randFloat()
+//~ {
+    //~ if (arguments.length == 0)
+    //~ {
+        //~ return Generator.RandFloat0();
+    //~ }
+    //~ else if (arguments.length == 2)
+    //~ {
+        //~ return Generator.RandFloat2(arguments[0], arguments[1]);
+    //~ }
+    //~ else
+    //~ {
+        //~ return undefined;
+    //~ }
+//~ }
+//~ function randInt()
+//~ {
+    //~ if (arguments.length == 1)
+    //~ {
+        //~ return Generator.RandInt1(arguments[0]);
+    //~ }
+    //~ else if (arguments.length == 2)
+    //~ {
+        //~ return Generator.RandInt2(arguments[0], arguments[1]);
+    //~ }
+    //~ else
+    //~ {
+        //~ return undefined;
+    //~ }
+//~ }

binaries/data/mods/public/maps/mapgen/terrain.js

+//////////////////////////////////////////////////////////////////////
+//  Terrain
+//////////////////////////////////////////////////////////////////////
+function Terrain() {}
+Terrain.prototype.place = function(x, y)
+{
+    // Clear old array
+    g_Map.terrainObjects[x][y] = [];
+    this.placeNew(x, y);
+};
+Terrain.prototype.placeNew = function() {};
+//////////////////////////////////////////////////////////////////////
+//  SimpleTerrain
+//////////////////////////////////////////////////////////////////////
+function SimpleTerrain(texture, treeType)
+{
+    if (texture === undefined)
+        error("SimpleTerrain: texture not defined");
+    this.texture = texture;
+    this.treeType = treeType;
+}
+SimpleTerrain.prototype = new Terrain();
+SimpleTerrain.prototype.constructor = SimpleTerrain;
+SimpleTerrain.prototype.placeNew = function(x, y)
+{
+    if (this.treeType !== undefined)
+        g_Map.terrainObjects[x][y].push(new Entity(this.treeType, 0, x+0.5, y+0.5, randFloat()*PI));
+    g_Map.texture[x][y] = g_Map.getID(this.texture);
+};
+//////////////////////////////////////////////////////////////////////
+//  RandomTerrain
+//////////////////////////////////////////////////////////////////////
+function RandomTerrain(terrains)
+{
+    if (!(terrains instanceof Array) || !terrains.length)
+        error("Invalid terrains array");
+    this.terrains = terrains;
+}
+RandomTerrain.prototype = new Terrain();
+RandomTerrain.prototype.constructor = RandomTerrain;
+RandomTerrain.prototype.placeNew = function(x, y)
+{
+    this.terrains[randInt(this.terrains.length)].placeNew(x, y);
+};

binaries/data/mods/public/maps/mapgen/tileclass.js

+//////////////////////////////////////////////////////////////////////
+//  RangeOp
+//////////////////////////////////////////////////////////////////////
+function RangeOp(size)
+{
+    // Get smallest power of 2 which is greater than or equal to size
+    this.nn = 1;
+    while (this.nn < size) {
+        this.nn *= 2;
+    }
+    this.vals = new Int16Array(2*this.nn);  // int16
+}
+RangeOp.prototype.set = function(pos, amt)
+{
+    this.add(pos, amt - this.vals[this.nn + pos]);
+};
+RangeOp.prototype.add = function(pos, amt)
+{
+    for(var s = this.nn; s >= 1; s /= 2)
+    {
+        this.vals[s + pos] += amt;
+        pos = Math.floor(pos/2);
+    }
+};
+RangeOp.prototype.get = function(start, end)
+{
+    var ret = 0;
+    var i;
+    var nn = this.nn;
+    // Count from start to end by powers of 2
+    for (i = 1; start+i <= end; i *= 2)
+    {
+        if (start & i)
+        {   // For each bit in start
+            ret += this.vals[nn/i + Math.floor(start/i)];
+            start += i;
+        }
+    }
+    //
+    while(i >= 1)
+    {
+        if(start+i <= end)
+        {
+            ret += this.vals[nn/i + Math.floor(start/i)];
+            start += i;
+        }
+        i /= 2;
+    }
+    return ret;
+};
+//////////////////////////////////////////////////////////////////////
+//  TileClass
+//////////////////////////////////////////////////////////////////////
+function TileClass(size)
+{
+    this.size = size;
+    this.inclusionCount = new Array(size);
+    this.rangeCount = new Array(size);
+    for (var i=0; i < size; ++i)
+    {
+        this.inclusionCount[i] = new Int16Array(size); //int16
+        this.rangeCount[i] = new RangeOp(size);
+    }
+}
+TileClass.prototype.add = function(x, y)
+{
+    if (!this.inclusionCount[x][y])
+    {
+        this.rangeCount[y].add(x, 1);
+    }
+    this.inclusionCount[x][y]++;
+};
+TileClass.prototype.remove = function(x, y)
+{
+    this.inclusionCount[x][y]--;
+    if(!this.inclusionCount[x][y])
+    {
+        this.rangeCount[y].add(x, -1);
+    }
+};
+TileClass.prototype.countInRadius = function(cx, cy, radius, returnMembers)
+{
+    var members = 0;
+    var nonMembers = 0;
+    var size = this.size;
+    var ymax = cy+radius;
+    for (var y = cy-radius; y <= ymax; y++)
+    {
+        var iy = Math.floor(y);
+        if(iy >= 0 && iy < size)
+        {
+            var dy = y - cy;
+            var dx = Math.sqrt(radius*radius - dy*dy);
+            var lowerX = Math.floor(cx - dx);
+            var upperX = Math.floor(cx + dx);
+            var minX = (lowerX > 0 ? lowerX : 0);
+            var maxX = (upperX < size ? upperX+1 : size);
+            var total = maxX - minX;
+            var mem = this.rangeCount[iy].get(minX, maxX);
+            members += mem;
+            nonMembers += total - mem;
+        }
+    }
+    if (returnMembers)
+        return members;
+    else
+        return nonMembers;
+};
+TileClass.prototype.countMembersInRadius = function(cx, cy, radius)
+{
+    return this.countInRadius(cx, cy, radius, true);
+};
+TileClass.prototype.countNonMembersInRadius = function(cx, cy, radius)
+{
+    return this.countInRadius(cx, cy, radius, false);
+};

binaries/data/mods/public/maps/mapgen/vector.js

+/////////////////////////////////////////////////////////////////////
+//  Vector2D
+/////////////////////////////////////////////////////////////////////
+// TODO: Type errors if v not instanceof Vector classes
+// TODO: Possible implement in C++
+function Vector2D(x, y)
+{
+    if (arguments.length == 2)
+    {
+        this.set(x, y);
+    }
+    else
+    {
+        this.set(0, 0);
+    }
+}
+Vector2D.prototype.set = function(x, y)
+{
+    this.x = x;
+    this.y = y;
+};
+Vector2D.prototype.add = function(v)
+{
+    return new Vector2D(this.x + v.x, this.y + v.y);
+};
+Vector2D.prototype.sub = function(v)
+{
+    return new Vector2D(this.x - v.x, this.y - v.y);
+};
+Vector2D.prototype.mult = function(f)
+{
+    return new Vector2D(this.x * f, this.y * f);
+};
+Vector2D.prototype.div = function(f)
+{
+    return new Vector2D(this.x / f, this.y / f);
+};
+Vector2D.prototype.dot = function(v)
+{
+    return this.x * v.x + this.y * v.y;
+};
+Vector2D.prototype.lengthSquared = function()
+{
+    return this.dot(this);
+};
+Vector2D.prototype.length = function()
+{
+    return sqrt(this.lengthSquared());
+};
+Vector2D.prototype.normalize = function()
+{
+    var mag = this.length();
+    this.x /= mag;
+    this.y /= mag;
+};
+/////////////////////////////////////////////////////////////////////
+//  Vector3D
+/////////////////////////////////////////////////////////////////////
+function Vector3D(x, y, z)
+{
+    if (arguments.length == 3)
+    {
+        this.set(x, y, z);
+    }
+    else
+    {
+        this.set(0, 0, 0);
+    }
+}
+Vector3D.prototype.set = function(x, y, z)
+{
+    this.x = x;
+    this.y = y;
+    this.z = z;
+};
+Vector3D.prototype.add = function(v)
+{
+    return new Vector3D(this.x + v.x, this.y + v.y, this.z + v.z);
+};
+Vector3D.prototype.sub = function(v)
+{
+    return new Vector3D(this.x - v.x, this.y - v.y, this.z - v.z);
+};
+Vector3D.prototype.mult = function(f)
+{
+    return new Vector3D(this.x * f, this.y * f, this.z * f);
+};
+Vector3D.prototype.div = function(f)
+{
+    return new Vector3D(this.x / f, this.y / f, this.z / f);
+};
+Vector3D.prototype.dot = function(v)
+{
+    return this.x * v.x + this.y * v.y + this.z * v.z;
+};
+Vector3D.prototype.lengthSquared = function()
+{
+    return this.dot(this);
+};
+Vector3D.prototype.length = function()
+{
+    return sqrt(this.lengthSquared());
+};
+Vector3D.prototype.normalize = function()
+{
+    var mag = this.length();
+    this.x /= mag;
+    this.y /= mag;
+    this.z /= mag;
+};

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

-// constants
+const SIZE = 208;
+const NUM_PLAYERS = 4;
+// terrain textures
+const tGrass = ["medit_grass_field_a", "medit_grass_field_b"];
+const tGrassForest = "medit_grass_wild";
+const tCliff = ["medit_cliff_italia", "medit_cliff_italia_grass"];
+const tForest = "medit_grass_field_a";
+const tGrassDirt75 = "medit_dirt";
+const tGrassDirt50 = "medit_dirt_b";
+const tGrassDirt25 = "medit_dirt_c";
+const tDirt = "medit_dirt_b";
+const tGrassPatch = "medit_grass_wild";
+const tShore = "medit_rocks";
+const tShoreBlend = "medit_rocks_grass";
+const tWater = "medit_rocks_wet";
+// gaia entities
+const oTree = "gaia/flora_tree_oak";
+const oTreeLarge = "gaia/flora_tree_oak";
+const oBerryBush = "gaia/flora_bush_berry";
+const oSheep = "gaia/fauna_sheep";
+const oDeer = "gaia/fauna_deer";
+const oMine = "gaia/geology_stone_temperate";
+const tGrass = ["grass_temperate_pasture_a", "grass_temperate_pasture_b"];
+const tGrassForest = "grass_temperate_a";
+const tCliff = ["cliff_temperate_granite", "cliff_temperate_brown"];
+const tForest = "forestfloor_temperate_a";
+const tGrassDirt75 = "grass_temperate_dirt_2";
+const tGrassDirt50 = "grass_temperate_dirt_b";
+const tGrassDirt25 = "grass_temperate_dry_dirt";
+const tDirt = "dirt_temperate_b_dry";
+const tGrassPatch = "grass_temperate_field_wild";
+const tShore = "shoreline_temperate_rocks";
+const tShoreBlend = "shoreline_temperate_rocks_dirt";
+const tWater = "sand_temperate_vegetation";
+// decorative props
+const aGrass = "actor|props/flora/grass_temp_field.xml";
+const aGrassShort = "actor|props/flora/grass_field_lush_short.xml";
+const aReeds = "actor|props/flora/grass_temp_field_dry.xml";
+const aRockLarge = "actor|geology/stone_granite_large.xml";
+const aRockMedium = "actor|geology/stone_granite_med.xml";
+const aBushMedium = "actor|props/flora/bush_tempe_me.xml";
+const aBushSmall = "actor|props/flora/bush_tempe_sm.xml";
+const oTree = "flora_tree_oak";
+const oTreeLarge = "flora_tree_oak";
+const oBerryBush = "flora_bush_berry";
+const oSheep = "fauna_sheep";
+const oDeer = "fauna_deer";
+const oMine = "geology_stone_temperate";
+const oGrass = "props/flora/grass_temp_field.xml";
+const oGrassShort = "props/flora/grass_field_lush_short.xml";
+const oReeds = "props/flora/grass_temp_field_dry.xml";
+const oRockLarge = "geology/stone_granite_large.xml";
+const oRockMedium = "flora_bush_temperate";
+const oBushMedium = "props/flora/bush_tempe_me.xml";
+const oBushSmall = "props/flora/bush_tempe_sm.xml";
+log("Initializing map...");
+// initialize map
+var numPlayers = getNumPlayers();
+var mapSize = getMapSize();
-println("Initializing map...");
-init(SIZE, tGrass, 3);
 // create tile classes
+clPlayer = createTileClass();
+clHill = createTileClass();
+clForest = createTileClass();
+clWater = createTileClass();
+clSettlement = createTileClass();
+clDirt = createTileClass();
+clRock = createTileClass();
+clFood = createTileClass();
+clBaseResource = createTileClass();
+var clPlayer = createTileClass();
+var clHill = createTileClass();
+var clForest = createTileClass();
+var clWater = createTileClass();
+var clDirt = createTileClass();
+var clRock = createTileClass();
+var clFood = createTileClass();
+var clBaseResource = createTileClass();
 // place players
 playerX = new Array(NUM_PLAYERS+1);
 playerY = new Array(NUM_PLAYERS+1);
 playerAngle = new Array(NUM_PLAYERS+1);
+var playerX = new Array(numPlayers+1);
+var playerY = new Array(numPlayers+1);
+var playerAngle = new Array(numPlayers+1);
+startAngle = randFloat() * 2 * PI;
+for(i=1; i<=NUM_PLAYERS; i++) {
+    playerAngle[i] = startAngle + i*2*PI/NUM_PLAYERS;
+var startAngle = randFloat() * 2 * PI;
+for (var i=1; i<=numPlayers; i++)
+{
+    playerAngle[i] = startAngle + i*2*PI/numPlayers;
     playerX[i] = 0.5 + 0.35*cos(playerAngle[i]);
     playerY[i] = 0.5 + 0.35*sin(playerAngle[i]);
+}
+for(i=1; i<=NUM_PLAYERS; i++) {
+    println("Creating base for player " + i + "...");
+for (var i=1; i<=numPlayers; i++)
+{
+    log("Creating base for player " + i + "...");
     // some constants
     radius = 17;
     cliffRadius = 2;
     elevation = 20;
+    var radius = 17;
+    var cliffRadius = 2;
+    var elevation = 20;
     // get the x and y in tiles
     fx = fractionToTiles(playerX[i]);
     fy = fractionToTiles(playerY[i]);
     ix = round(fx);
     iy = round(fy);
+    var fx = fractionToTiles(playerX[i]);
+    var fy = fractionToTiles(playerY[i]);
+    var ix = round(fx);
+    var iy = round(fy);
     // calculate size based on the radius
     size = PI * radius * radius;
+    var size = PI * radius * radius;
     // create the hill
     placer = new ClumpPlacer(size, 0.95, 0.6, 0, ix, iy);
     terrainPainter = new LayeredPainter(
         [cliffRadius],      // widths
         [tCliff, tGrass]        // terrains
+    var placer = new ClumpPlacer(size, 0.95, 0.6, 0, ix, iy);
+    var terrainPainter = new LayeredPainter(
+        [tCliff, tGrass],       // terrains
+        [cliffRadius]       // widths
     );
     elevationPainter = new SmoothElevationPainter(
+    var elevationPainter = new SmoothElevationPainter(
         ELEVATION_SET,          // type
         elevation,              // elevation
         cliffRadius             // blend radius
 …
     createArea(placer, [terrainPainter, elevationPainter, paintClass(clPlayer)], null);
     // create the ramp
     rampAngle = playerAngle[i] + PI + (2*randFloat()-1)*PI/8;
     rampDist = radius - 1;
     rampX = round(fx + rampDist * cos(rampAngle));
     rampY = round(fy + rampDist * sin(rampAngle));
+    var rampAngle = playerAngle[i] + PI + (2*randFloat()-1)*PI/8;
+    var rampDist = radius - 1;
+    var rampX = round(fx + rampDist * cos(rampAngle));
+    var rampY = round(fy + rampDist * sin(rampAngle));
     placer = new ClumpPlacer(100, 0.9, 0.5, 0, rampX, rampY);
     painter = new SmoothElevationPainter(ELEVATION_SET, elevation-6, 5);
+    var painter = new SmoothElevationPainter(ELEVATION_SET, elevation-6, 5);
     createArea(placer, painter, null);
     placer = new ClumpPlacer(75, 0.9, 0.5, 0, rampX, rampY);
     painter = new TerrainPainter(tGrass);
 …
     // create the central dirt patch
     placer = new ClumpPlacer(PI*3.5*3.5, 0.3, 0.1, 0, ix, iy);
     painter = new LayeredPainter(
         [1,1,1],                                                // widths
         [tGrassDirt75, tGrassDirt50, tGrassDirt25, tDirt]       // terrains
+        [tGrassDirt75, tGrassDirt50, tGrassDirt25, tDirt],      // terrains
+        [1,1,1]                                 // widths
     );
     createArea(placer, painter, null);
+    // create the TC and the "villies"
+    group = new SimpleGroup(
+        [                           // elements (type, count, distance)
+            new SimpleObject("hele_civil_centre", 1,1, 0,0),
+            new SimpleObject("hele_infantry_javelinist_b", 3,3, 5,5)
+        ],
+        true, null, ix, iy
+    // create the TC and citizens
+    var civ = getCivCode(i - 1);
+    var group = new SimpleGroup(    // elements (type, min/max count, min/max distance)
+        [new SimpleObject("structures/"+civ+"_civil_centre", 1,1, 0,0), new SimpleObject("units/"+civ+"_support_female_citizen", 3,3, 5,5)],
+        true, null, ix, iy
     );
     createObjectGroup(group, i);
-    // Create the Settlement under the TC
-    group = new SimpleGroup(
-        [new SimpleObject("special_settlement", 1,1, 0,0)],
-        true, null, ix, iy
-    );
-    createObjectGroup(group, 0);
     // create berry bushes
     bbAngle = randFloat()*2*PI;
     bbDist = 9;
     bbX = round(fx + bbDist * cos(bbAngle));
     bbY = round(fy + bbDist * sin(bbAngle));
+    var bbAngle = randFloat()*2*PI;
+    var bbDist = 9;
+    var bbX = round(fx + bbDist * cos(bbAngle));
+    var bbY = round(fy + bbDist * sin(bbAngle));
     group = new SimpleGroup(
         [new SimpleObject(oBerryBush, 5,5, 0,2)],
         true, clBaseResource, bbX, bbY
 …
     createObjectGroup(group, 0);
     // create mines
+    mAngle = bbAngle;
+    while(abs(mAngle - bbAngle) < PI/3) {
+    var mAngle = bbAngle;
+    while(abs(mAngle - bbAngle) < PI/3)
+    {
         mAngle = randFloat()*2*PI;
+    }
     mDist = 9;
     mX = round(fx + mDist * cos(mAngle));
     mY = round(fy + mDist * sin(mAngle));
+    var mDist = 9;
+    var mX = round(fx + mDist * cos(mAngle));
+    var mY = round(fy + mDist * sin(mAngle));
     group = new SimpleGroup(
         [new SimpleObject(oMine, 4,4, 0,2)],
         true, clBaseResource, mX, mY
 …
     createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
     // create grass tufts
+    for(j=0; j<10; j++) {
+        gAngle = randFloat()*2*PI;
+        gDist = 6 + randInt(9);
+        gX = round(fx + gDist * cos(gAngle));
+        gY = round(fy + gDist * sin(gAngle));
+        group = new SimpleGroup([new SimpleObject(oGrassShort, 3,6, 0,1, -PI/8,PI/8)],
+            false, clBaseResource, gX, gY);
+        createObjectGroup(group, 0);
+    for (var j=0; j < 10; j++)
+    {
+        var gAngle = randFloat()*2*PI;
+        var gDist = 6 + randInt(9);
+        var gX = round(fx + gDist * cos(gAngle));
+        var gY = round(fy + gDist * sin(gAngle));
+        group = new SimpleGroup(
+            [new SimpleObject(aGrassShort, 3,6, 0,1, -PI/8,PI/8)],
+            false, clBaseResource, gX, gY
+        );
+        createObjectGroup(group, undefined);
+    }
+}
 // create lakes
+println("Creating lakes...");
+log("Creating lakes...");
+//console.profile();
 placer = new ClumpPlacer(140, 0.8, 0.1, 0);
 terrainPainter = new LayeredPainter(
     [1,1],                                  // widths
     [tShoreBlend, tShore, tWater]       // terrains
+    [tShoreBlend, tShore, tWater],      // terrains
+    [1,1]                           // widths
 );
 elevationPainter = new SmoothElevationPainter(ELEVATION_SET, -7, 3);
+createAreas(placer, [terrainPainter, elevationPainter, paintClass(clWater)],
+createAreas(
+    placer,
+    [terrainPainter, elevationPainter, paintClass(clWater)],
     avoidClasses(clPlayer, 2, clWater, 20),
     round(1.3 * NUM_PLAYERS)
+    round(1.3 * numPlayers)
 );
+//console.profileEnd();
 // create bumps
 println("Creating bumps...");
+log("Creating bumps...");
 placer = new ClumpPlacer(10, 0.3, 0.06, 0);
 painter = new SmoothElevationPainter(ELEVATION_MODIFY, 2, 2);
+createAreas(placer, painter,
+createAreas(
+    placer,
+    painter,
     avoidClasses(clWater, 2, clPlayer, 0),
     SIZE*SIZE/100
+    mapSize*mapSize/100
 );
 // create hills
 println("Creating hills...");
+log("Creating hills...");
 placer = new ClumpPlacer(30, 0.2, 0.1, 0);
 terrainPainter = new LayeredPainter(
     [3],                    // widths
     [tCliff, [tGrass,tGrass,tGrassDirt75]]      // terrains
+    [tCliff, [tGrass,tGrass,tGrassDirt75]],     // terrains
+    [3]                             // widths
 );
 elevationPainter = new SmoothElevationPainter(ELEVATION_SET, 12, 2);
+createAreas(placer, [terrainPainter, elevationPainter, paintClass(clHill)],
+createAreas(
+    placer,
+    [terrainPainter, elevationPainter, paintClass(clHill)],
     avoidClasses(clPlayer, 2, clWater, 5, clHill, 15),
 * NUM_PLAYERS
+* numPlayers
 );
 // create forests
 println("Creating forests...");
+log("Creating forests...");
 placer = new ClumpPlacer(32, 0.1, 0.1, 0);
+painter = new LayeredPainter([2], [[tGrassForest, tGrass, tForest],
+    [tGrassForest, tForest]]);
+createAreas(placer, [painter, paintClass(clForest)],
+painter = new LayeredPainter(
+    [[tGrassForest, tGrass, tForest], [tGrassForest, tForest]],     // terrains
+    [2]                                         // widths
+    );
+createAreas(
+    placer,
+    [painter, paintClass(clForest)],
     avoidClasses(clPlayer, 1, clWater, 3, clForest, 10, clHill, 0),
 * NUM_PLAYERS
+* numPlayers
 );
 // create dirt patches
 println("Creating dirt patches...");
+log("Creating dirt patches...");
 var sizes = [8,14,20];
+for(i=0; i<sizes.length; i++) {
+for (i=0; i<sizes.length; i++)
+{
     placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0);
+    painter = new LayeredPainter([1,1], [
+        [tGrass,tGrassDirt75],[tGrassDirt75,tGrassDirt50],
+        [tGrassDirt50,tGrassDirt25]]);
+    createAreas(placer, [painter, paintClass(clDirt)],
+    painter = new LayeredPainter(
+        [[tGrass,tGrassDirt75],[tGrassDirt75,tGrassDirt50], [tGrassDirt50,tGrassDirt25]],       // terrains
+        [1,1]                                                           // widths
+    );
+    createAreas(
+        placer,
+        [painter, paintClass(clDirt)],
         avoidClasses(clWater, 1, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 0),
         SIZE*SIZE/4000
+        mapSize*mapSize/4000
     );
+}
 // create grass patches
 println("Creating grass patches...");
+log("Creating grass patches...");
 var sizes = [5,9,13];
+for(i=0; i<sizes.length; i++) {
+for (i=0; i<sizes.length; i++)
+{
     placer = new ClumpPlacer(sizes[i], 0.3, 0.06, 0);
     painter = new TerrainPainter(tGrassPatch);
+    createAreas(placer, painter,
+    createAreas(
+        placer,
+        painter,
         avoidClasses(clWater, 1, clForest, 0, clHill, 0, clDirt, 5, clPlayer, 0),
         SIZE*SIZE/4000
+        mapSize*mapSize/4000
     );
+}
 // create mines
+println("Creating mines...");
+group = new SimpleGroup([new SimpleObject(oMine, 4,6, 0,2)], true, clRock);
+createObjectGroups(group, 0,
+log("Creating mines...");
+group = new SimpleGroup(
+    [new SimpleObject(oMine, 4,6, 0,2)],
+    true, clRock
+);
+createObjectGroups(
+    group, 0,
     [avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clRock, 13),
      new BorderTileClassConstraint(clHill, 0, 4)],
 * NUM_PLAYERS, 100
+* numPlayers, 100
 );
-// create settlements
-println("Creating settlements...");
-group = new SimpleGroup([new SimpleObject("special_settlement", 1,1, 0,0)], true, clSettlement);
-createObjectGroups(group, 0,
-    avoidClasses(clWater, 0, clForest, 0, clPlayer, 15, clHill, 0, clRock, 5, clSettlement, 35),
-* NUM_PLAYERS, 50
-);
 // create small decorative rocks
+println("Creating large decorative rocks...");
+group = new SimpleGroup([new SimpleObject(oRockMedium, 1,3, 0,1)], true);
+createObjectGroups(group, 0,
+    avoidClasses(clForest, 0, clPlayer, 0, clHill, 0, clSettlement, 3),
+    SIZE*SIZE/1000, 50
+log("Creating large decorative rocks...");
+group = new SimpleGroup(
+    [new SimpleObject(aRockMedium, 1,3, 0,1)],
+    true
 );
+createObjectGroups(
+    group, undefined,
+    avoidClasses(clForest, 0, clPlayer, 0, clHill, 0),
+    mapSize*mapSize/1000, 50
+);
 // create large decorative rocks
+println("Creating large decorative rocks...");
+group = new SimpleGroup([new SimpleObject(oRockLarge, 1,2, 0,1),
+    new SimpleObject(oRockMedium, 1,3, 0,2)], true);
+createObjectGroups(group, 0,
+    avoidClasses(clForest, 0, clPlayer, 0, clHill, 0, clSettlement, 5),
+    SIZE*SIZE/2000, 50
+log("Creating large decorative rocks...");
+group = new SimpleGroup(
+    [new SimpleObject(aRockLarge, 1,2, 0,1), new SimpleObject(aRockMedium, 1,3, 0,2)],
+    true
 );
+createObjectGroups(
+    group, undefined,
+    avoidClasses(clForest, 0, clPlayer, 0, clHill, 0),
+    mapSize*mapSize/2000, 50
+);
 // create deer
+println("Creating deer...");
+group = new SimpleGroup([new SimpleObject(oDeer, 5,7, 0,4)], true, clFood);
+log("Creating deer...");
+group = new SimpleGroup(
+    [new SimpleObject(oDeer, 5,7, 0,4)],
+    true, clFood
+);
 createObjectGroups(group, 0,
     avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0, clFood, 20, clSettlement, 5),
 * NUM_PLAYERS, 50
+    avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0, clFood, 20),
+* numPlayers, 50
 );
 // create sheep
+println("Creating sheep...");
+group = new SimpleGroup([new SimpleObject(oSheep, 2,3, 0,2)], true, clFood);
+log("Creating sheep...");
+group = new SimpleGroup(
+    [new SimpleObject(oSheep, 2,3, 0,2)],
+    true, clFood
+);
 createObjectGroups(group, 0,
     avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0, clFood, 20, clSettlement, 5),
 * NUM_PLAYERS, 50
+    avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill, 0, clFood, 20),
+* numPlayers, 50
 );
 // create straggler trees
+println("Creating straggler trees...");
+group = new SimpleGroup([new SimpleObject(oTree, 1,1, 0,0)], true);
+log("Creating straggler trees...");
+group = new SimpleGroup(
+    [new SimpleObject(oTree, 1,1, 0,0)],
+    true
+);
 createObjectGroups(group, 0,
     avoidClasses(clWater, 1, clForest, 1, clHill, 1, clPlayer, 1, clSettlement, 2),
     SIZE*SIZE/1100
+    avoidClasses(clWater, 1, clForest, 1, clHill, 1, clPlayer, 1),
+    mapSize*mapSize/1100
 );
 // create small grass tufts
+println("Creating small grass tufts...");
+group = new SimpleGroup([new SimpleObject(oGrassShort, 3,6, 0,1, -PI/8,PI/8)]);
+createObjectGroups(group, 0,
+log("Creating small grass tufts...");
+group = new SimpleGroup(
+    [new SimpleObject(aGrassShort, 3,6, 0,1, -PI/8,PI/8)]
+);
+createObjectGroups(group, undefined,
     avoidClasses(clWater, 2, clHill, 2, clPlayer, 2, clDirt, 0),
     SIZE*SIZE/90
+    mapSize*mapSize/90
 );
 // create large grass tufts
+println("Creating large grass tufts...");
+group = new SimpleGroup([new SimpleObject(oGrass, 20,30, 0,1.8, -PI/8,PI/8),
+    new SimpleObject(oGrassShort, 20,30, 1.2,2.5, -PI/8,PI/8)]);
+createObjectGroups(group, 0,
+log("Creating large grass tufts...");
+group = new SimpleGroup(
+    [new SimpleObject(aGrass, 20,30, 0,1.8, -PI/8,PI/8), new SimpleObject(aGrassShort, 20,30, 1.2,2.5, -PI/8,PI/8)]
+);
+createObjectGroups(group, undefined,
     avoidClasses(clWater, 3, clHill, 2, clPlayer, 2, clDirt, 1, clForest, 0),
     SIZE*SIZE/900
+    mapSize*mapSize/900
 );
 // create bushes
+println("Creating bushes...");
+group = new SimpleGroup([new SimpleObject(oBushSmall, 2,4, 0,2)]);
+createObjectGroups(group, 0,
+log("Creating bushes...");
+group = new SimpleGroup(
+    [new SimpleObject(aBushSmall, 2,4, 0,2)]
+);
+createObjectGroups(group, undefined,
     avoidClasses(clWater, 1, clHill, 1, clPlayer, 1, clDirt, 1),
     SIZE*SIZE/2000, 50
+    mapSize*mapSize/2000, 50
 );
 // create reeds
+println("Creating reeds...");
+group = new SimpleGroup([new SimpleObject(oReeds, 5,10, 0,1.5, -PI/8,PI/8)]);
+createObjectGroups(group, 0,
+log("Creating reeds...");
+group = new SimpleGroup(
+    [new SimpleObject(aReeds, 5,10, 0,1.5, -PI/8,PI/8)]
+);
+createObjectGroups(group, undefined,
     [new BorderTileClassConstraint(clWater, 3, 0), new StayInTileClassConstraint(clWater, 1)],
 * NUM_PLAYERS, 100
+* numPlayers, 100
 );

binaries/data/mods/public/maps/random/cantabrian_highlands.json

+{
+    "settings" : {
+        "Name" : "Cantabrian Highlands",
+        "Script" : "cantabrian_highlands.js",
+        "Description" : "A test of the Cantabrian Highlands script",
+        "BaseTerrain" : ["medit_grass_field_a", "medit_grass_field_b"],
+        "BaseHeight" : 3,
+        "RevealMap": true,
+        "GameType": "endless",
+        "XXXXXX" : "Optionally define other things here, like we would for a scenario"
+    }
+}
+ No newline at end of file

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

Property changes on: binaries\data\mods\public\maps\random\cantabrian_highlands.json
___________________________________________________________________
Added: svn:eol-style
   + native

-const SIZE = 176;
-const NUM_PLAYERS = 4;
-const WATER_WIDTH = .2;
-// Terrain and object constants
-tOceanDepths = "ocean_medit_depths";
-tOceanRockDeep = "ocean_medit_rock_deep";
-tOceanRockShallow = "ocean_medit_rock_shallow";
-tOceanCoral = "ocean_medit_coral";
-tBeachWet = "beach_medit_wet";
-tBeachDry = "beach_medit_dry";
-tBeachGrass = "beach_medit_grass_50";
-tBeachCliff = "cliff_medit_beach";
-tGrassDry = ["grass_mediterranean_dry_a", "grass_mediterranean_dry_b", "grass_mediterranean_dry_c"];
-tGrass = ["grass_mediterranean_green_50", "grass_mediterranean_green_flowers"];
-tGrassLush = ["grass_temperate_dry_tufts", "grass_mediterranean_green_flowers"];
-tGrassShrubs = ["grass_mediterranean_green_shrubs", "grass_mediterranean_green_flowers"];
-tGrassRock = ["grass_mediterranean_green_rock"];
-tDirt = "dirt_medit_a";
-tDirtGrass = "dirt_medit_grass_50";
-tDirtCliff = "cliff_medit_dirt";
-tGrassCliff = "cliff_medit_grass_a";
-tCliff = ["cliff_medit_face_b", "cliff_medit_face_b", "cliff_medit_foliage_a"];
-tForestFloor = "forestfloor_medit_dirt";
-oPalm = "flora_tree_medit_fan_palm";
-oLombardyPoplar = "flora_tree_poplar_lombardy";
-oOak = "flora_tree_oak";
-oPoplar = "flora_tree_poplar";
-oCarob = "flora_tree_carob";
-oBeech = "flora_tree_euro_beech";
-oPine = "flora_tree_aleppo_pine";
-oBerryBush = "flora_bush_berry";
-oSheep = "fauna_sheep";
-oStone = "geology_stone_greek";
-oMetal = "geology_metal_greek";
-oBushLargeDry = "props/flora/bush_medit_la_dry.xml";
-oBushLarge = "props/flora/bush_medit_la.xml";
-oBushMedDry = "props/flora/bush_medit_me_dry.xml";
-oBushMed = "props/flora/bush_medit_me.xml";
-oBushSmall = "props/flora/bush_medit_sm.xml"
-oBushSmallDry = "props/flora/bush_medit_sm_dry.xml"
-oGrass = "props/flora/grass_medit_field.xml";
-oGrassDry = "props/flora/grass_soft_dry_small.xml";
-oRockLarge = "geology/stone_granite_greek_large.xml";
-oRockMed = "geology/stone_granite_greek_med.xml";
-oRockSmall = "geology/stone_granite_greek_small.xml";
-oWaterLog = "props/flora/water_log.xml";
-tPalmForest = [tForestFloor+"|"+oPalm, tGrass];
-tPineForest = [tForestFloor+"|"+oPine, tGrass];
-tMainForest = [tForestFloor+"|"+oCarob, tForestFloor+"|"+oBeech, tGrass, tGrass];
-tPoplarForest = [tForestFloor+"|"+oLombardyPoplar, tGrass];
-// Initialize world
-init(SIZE, tGrass, 0);
-// Create classes
-clWater = createTileClass();
-clCliff = createTileClass();
-clForest = createTileClass();
-clMetal = createTileClass();
-clStone = createTileClass();
-clFood = createTileClass();
-clPlayer = createTileClass();
-clBaseResource = createTileClass();
-clSettlement = createTileClass();
-// Place players
-println("Placing players...");
-playerX = new Array(NUM_PLAYERS+1);
-playerY = new Array(NUM_PLAYERS+1);
-numLeftPlayers = Math.floor(NUM_PLAYERS/2);
-for(i=1; i<=numLeftPlayers; i++) {
-    playerX[i] = 0.28 + (2*randFloat()-1)*0.01;
-    playerY[i] = (0.5+i-1)/numLeftPlayers + (2*randFloat()-1)*0.01;
+}
-for(i=numLeftPlayers+1; i<=NUM_PLAYERS; i++) {
-    playerX[i] = 0.72 + (2*randFloat()-1)*0.01;
-    playerY[i] = (0.5+i-numLeftPlayers-1)/numLeftPlayers + (2*randFloat()-1)*0.01;
+}
-for(i=1; i<=NUM_PLAYERS; i++) {
-    // get fractional locations in tiles
-    ix = round(fractionToTiles(playerX[i]));
-    iy = round(fractionToTiles(playerY[i]));
-    addToClass(ix, iy, clPlayer);
-    // create TC and starting units
-    placeObject("special_settlement", i, ix, iy, PI*3/4);
-    placeObject("hele_civil_centre", i, ix, iy, PI*3/4);
-    group = new SimpleGroup(
-        [new SimpleObject("hele_infantry_javelinist_b", 3,3, 5,5)],
-        true, null, ix, iy
-    );
-    createObjectGroup(group, i);
-    // create starting berry bushes
-    bbAngle = randFloat()*2*PI;
-    bbDist = 9;
-    bbX = round(ix + bbDist * cos(bbAngle));
-    bbY = round(iy + bbDist * sin(bbAngle));
-    group = new SimpleGroup(
-        [new SimpleObject(oBerryBush, 5,5, 0,2)],
-        true, clBaseResource, bbX, bbY
-    );
-    createObjectGroup(group, 0);
-    // create starting mines
-    mAngle = bbAngle;
-    while(abs(mAngle - bbAngle) < PI/3) {
-        mAngle = randFloat()*2*PI;
+    }
-    mDist = 9;
-    mX = round(ix + mDist * cos(mAngle));
-    mY = round(iy + mDist * sin(mAngle));
-    group = new SimpleGroup(
-        [new SimpleObject(oStone, 2,2, 0,3),
-        new SimpleObject(oMetal, 2,2, 0,3)],
-        true, clBaseResource, mX, mY
-    );
-    createObjectGroup(group, 0);
-    // create starting straggler trees
-    group = new SimpleGroup(
-        [new SimpleObject(oPalm, 3,3, 7,10)],
-        true, clBaseResource, ix, iy
-    );
-    createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
+}
-function distanceToPlayers(x, y) {
-    var r = 10000;
-    for(var i=1; i<=NUM_PLAYERS; i++) {
-        var dx = x-playerX[i];
-        var dy = y-playerY[i];
-        r = min(r, dx*dx + dy*dy);
+    }
-    return Math.sqrt(r);
+}
-function playerNearness(x, y) {
-    var d = fractionToTiles(distanceToPlayers(x,y));
-    if(d < 13) return 0;
-    else if(d < 19) return (d-13)/(19-13);
-    else return 1;
+}
-function max(x, y) {
-    return x > y ? x : y;
+}
-function min(x, y) {
-    return x < y ? x : y;
+}
-// Paint elevation
-println("Painting elevation...");
-noise0 = new Noise2D(4 * SIZE/128);
-noise1 = new Noise2D(8 * SIZE/128);
-noise2 = new Noise2D(15 * SIZE/128);
-noise2a = new Noise2D(20 * SIZE/128);
-noise2b = new Noise2D(35 * SIZE/128);
-noise3 = new Noise2D(4 * SIZE/128);
-noise4 = new Noise2D(6 * SIZE/128);
-noise5 = new Noise2D(11 * SIZE/128);
-for(ix=0; ix<=SIZE; ix++) {
-    for(iy=0; iy<=SIZE; iy++) {
-        x = ix / (SIZE + 1.0);
-        y = iy / (SIZE + 1.0);
-        pn = playerNearness(x, y);
-        h = 0;
-        distToWater = 0;
-        h = 32 * (x-.5);
-        // add the rough shape of the water
-        if(x < WATER_WIDTH) {
-            h = max(-16.0, -28.0*(WATER_WIDTH-x)/WATER_WIDTH);
+        }
-        else if(x > 1.0-WATER_WIDTH) {
-            h = max(-16.0, -28.0*(x-(1.0-WATER_WIDTH))/WATER_WIDTH);
+        }
-        else {
-            distToWater = (0.5 - WATER_WIDTH - Math.abs(x-0.5));
-            u = 1 - Math.abs(x-0.5) / (0.5-WATER_WIDTH);
-            h = 12*u;
+        }
-        // add some base noise
-        baseNoise = 16*noise0.eval(x,y) + 8*noise1.eval(x,y) + 4*noise2.eval(x,y) - (16+8+4)/2;
-        if( baseNoise < 0 ) {
-            baseNoise *= pn;
-            baseNoise *= max(0.1, distToWater / (0.5-WATER_WIDTH));
+        }
-        oldH = h;
-        h += baseNoise;
-        // add some higher-frequency noise on land
-        if( oldH > 0 )
+        {
-            h += (0.4*noise2a.eval(x,y) + 0.2*noise2b.eval(x,y)) * min(oldH/10.0, 1.0);
+        }
-        // create cliff noise
-        if( h > -10 )
+        {
-            cliffNoise = (1*noise3.eval(x,y) + 0.5*noise4.eval(x,y)) / 1.5;
-            if(h < 1) {
-                u = 1 - .3*((h-1)/-10);
-                cliffNoise *= u;
+            }
-            cliffNoise += .05 * distToWater / (0.5 - WATER_WIDTH);
-            if(cliffNoise > .6) {
-                u = 0.8 * (cliffNoise-.6);
-                cliffNoise += u * noise5.eval(x,y);
-                cliffNoise /= (1+u);
+            }
-            cliffNoise -= 0.59;
-            cliffNoise *= pn;
-            if(cliffNoise > 0) {
-                h += 19 * min(cliffNoise, 0.045) / 0.045;
+            }
+        }
-        // set the height
-        setHeight(ix, iy, h);
+    }
+}
-// Paint base terrain
-println("Painting terrain...");
-noise6 = new Noise2D(10 * SIZE/128);
-noise7 = new Noise2D(20 * SIZE/128);
-noise8 = new Noise2D(13 * SIZE/128);
-noise9 = new Noise2D(26 * SIZE/128);
-noise10 = new Noise2D(50 * SIZE/128);
-for(ix=0; ix<SIZE; ix++) {
-    for(iy=0; iy<SIZE; iy++) {
-        x = ix / (SIZE + 1.0);
-        y = iy / (SIZE + 1.0);
-        pn = playerNearness(x, y);
-        // get heights of surrounding vertices
-        h00 = getHeight(ix, iy);
-        h01 = getHeight(ix, iy+1);
-        h10 = getHeight(ix+1, iy);
-        h11 = getHeight(ix+1, iy+1);
-        // find min and max height
-        maxH = max(h00, h01, h10, h11);
-        minH = min(h00, h01, h10, h11);
-        // figure out if we're at the top of a cliff using min adjacent height
-        minAdjHeight = minH;
-        if(maxH > 15) {
-            for(nx=max(ix-1, 0); nx<=min(ix+2, SIZE); nx++) {
-                for(ny=max(iy-1, 0); ny<=min(iy+2, SIZE); ny++) {
-                    minAdjHeight = min(minAdjHeight, getHeight(nx, ny));
+                }
+            }
+        }
-        // choose a terrain based on elevation
-        t = tGrass;
-        // water
-        if(maxH < -12) {
-            t = tOceanDepths;
+        }
-        else if(maxH < -8.8) {
-            t = tOceanRockDeep;
+        }
-        else if(maxH < -4.7) {
-            t = tOceanCoral;
+        }
-        else if(maxH < -2.8) {
-            t = tOceanRockShallow;
+        }
-        else if(maxH < .9 && minH < .35) {
-            t = tBeachWet;
+        }
-        else if(maxH < 1.5 && minH < .9) {
-            t = tBeachDry;
+        }
-        else if(maxH < 2.3 && minH < 1.3) {
-            t = tBeachGrass;
+        }
-        if(minH < 0) {
-            addToClass(ix, iy, clWater);
+        }
-        // cliffs
-        if(maxH - minH > 2.9 && minH > -7) {
-            t = tCliff;
-            addToClass(ix, iy, clCliff);
+        }
-        else if((maxH - minH > 2.5 && minH > -5) || (maxH-minAdjHeight > 2.9 && minH > 0) ) {
-            if(minH < -1) t = tCliff;
-            else if(minH < .5) t = tBeachCliff;
-            else t = [tDirtCliff, tGrassCliff, tGrassCliff, tGrassRock, tCliff];
-            addToClass(ix, iy, clCliff);
+        }
-        // forests
-        if(maxH - minH < 1 && minH > 1) {
-            forestNoise = (noise6.eval(x,y) + 0.5*noise7.eval(x,y)) / 1.5 * pn;
-            forestNoise -= 0.59;
-            if(forestNoise > 0) {
-                if(minH > 5) {
-                    typeNoise = noise10.eval(x,y);
-                    if(typeNoise < .43 && forestNoise < .05) t = tPoplarForest;
-                    else if(typeNoise < .63) t = tMainForest;
-                    else t = tPineForest;
-                    addToClass(ix, iy, clForest);
+                }
-                else if(minH < 3) {
-                    t = tPalmForest;
-                    addToClass(ix, iy, clForest);
+                }
+            }
+        }
-        // grass variations
-        if(t==tGrass)
+        {
-            grassNoise = (noise8.eval(x,y) + .6*noise9.eval(x,y)) / 1.6;
-            if(grassNoise < .3) {
-                t = (maxH - minH > 1.2) ? tDirtCliff : tDirt;
+            }
-            else if(grassNoise < .34) {
-                t = (maxH - minH > 1.2) ? tGrassCliff : tGrassDry;
-                if(maxH - minH < .5 && randFloat() < .03) {
-                    placeObject(oGrassDry, 0, ix+randFloat(), iy+randFloat(), randFloat()*2*Math.PI);
+                }
+            }
-            else if(grassNoise > .61) {
-                t = (maxH - minH > 1.2) ? tGrassRock : tGrassShrubs;
+            }
-            else {
-                if(maxH - minH < .5 && randFloat() < .05) {
-                    placeObject(oGrass, 0, ix+randFloat(), iy+randFloat(), randFloat()*2*Math.PI);
+                }
+            }
+        }
-        placeTerrain(ix, iy, t);
+    }
+}
-println("Placing object groups...");
-// create settlements
-group = new SimpleGroup([new SimpleObject("special_settlement", 1,1, 0,0)], true, clSettlement);
-createObjectGroups(group, 0,
-    avoidClasses(clWater, 5, clForest, 4, clPlayer, 25, clCliff, 4, clSettlement, 35),
-* NUM_PLAYERS, 50
-);
-// create straggler trees
-trees = [oCarob, oBeech, oLombardyPoplar, oLombardyPoplar, oPine]
-for(t in trees) {
-    group = new SimpleGroup([new SimpleObject(trees[t], 1,1, 0,1)], true, clForest);
-    createObjectGroups(group, 0,
-        avoidClasses(clWater, 5, clCliff, 0, clForest, 1, clSettlement, 4, clPlayer, 15),
-        SIZE*SIZE/7000, 50
-    );
+}
-// create cypresses
-group = new SimpleGroup([
-    new SimpleObject("flora/trees/cypress2.xml", 1,3, 0,3),
-    new SimpleObject("flora/trees/cypress1.xml", 0,2, 0,2)]);
-createObjectGroups(group, 0,
-    avoidClasses(clWater, 4, clCliff, 2, clForest, 1, clSettlement, 4, clPlayer, 15),
-    SIZE*SIZE/3500, 50
-);
-// create bushes
-group = new SimpleGroup([
-    new SimpleObject(oBushSmall, 0,2, 0,2),
-    new SimpleObject(oBushSmallDry, 0,2, 0,2),
-    new SimpleObject(oBushMed, 0,1, 0,2),
-    new SimpleObject(oBushMedDry, 0,1, 0,2)]);
-createObjectGroups(group, 0,
-    avoidClasses(clWater, 4, clCliff, 2),
-    SIZE*SIZE/1800, 50
-);
-// create rocks
-group = new SimpleGroup([
-    new SimpleObject(oRockSmall, 0,3, 0,2),
-    new SimpleObject(oRockMed, 0,2, 0,2),
-    new SimpleObject(oRockLarge, 0,1, 0,2)]);
-createObjectGroups(group, 0,
-    avoidClasses(clWater, 0, clCliff, 0),
-    SIZE*SIZE/1800, 50
-);
-// create stone
-group = new SimpleGroup([new SimpleObject(oStone, 2,3, 0,2)], true, clStone);
-createObjectGroups(group, 0,
-    [avoidClasses(clWater, 0, clForest, 0, clPlayer, 20, clStone, 15, clSettlement, 4),
-     new BorderTileClassConstraint(clCliff, 0, 5)],
-* NUM_PLAYERS, 100
-);
-// create metal
-group = new SimpleGroup([new SimpleObject(oMetal, 2,3, 0,2)], true, clMetal);
-createObjectGroups(group, 0,
-    [avoidClasses(clWater, 0, clForest, 0, clPlayer, 20, clMetal, 15, clStone, 5, clSettlement, 4),
-     new BorderTileClassConstraint(clCliff, 0, 5)],
-* NUM_PLAYERS, 100
-);
-// create sheep
-group = new SimpleGroup([new SimpleObject(oSheep, 2,4, 0,2)], true, clFood);
-createObjectGroups(group, 0,
-    avoidClasses(clWater, 5, clForest, 1, clCliff, 1, clPlayer, 20,
-        clMetal, 2, clStone, 2, clFood, 8, clSettlement, 4),
-* NUM_PLAYERS, 100
-);
-// create berry bushes
-group = new SimpleGroup([new SimpleObject(oBerryBush, 5,7, 0,3)], true, clFood);
-createObjectGroups(group, 0,
-    avoidClasses(clWater, 5, clForest, 1, clCliff, 1, clPlayer, 20,
-        clMetal, 2, clStone, 2, clFood, 8, clSettlement, 4),
-.5 * NUM_PLAYERS, 100
-);

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

+const WATER_WIDTH = 0.2;
+// terrain textures
+const tOceanDepths = "medit_sea_depths";
+const tOceanRockDeep = "medit_sea_coral_deep";
+const tOceanRockShallow = "medit_rocks_wet";
+const tOceanCoral = "medit_sea_coral_plants";
+const tBeachWet = "medit_sand_wet";
+const tBeachDry = "medit_sand";
+const tBeachGrass = "beach_medit_grass_50";
+const tBeachCliff = "cliff_medit_beach";
+const tGrassDry = ["medit_grass_field_brown", "medit_grass_field_dry", "medit_grass_field_b"];
+const tGrass = ["medit_grass_field", "medit_grass_field_a", "medit_grass_flowers"];
+const tGrassLush = ["grass_temperate_dry_tufts", "medit_grass_flowers"];
+const tGrassShrubs = ["medit_grass_shrubs", "medit_grass_flowers"];
+const tGrassRock = ["medit_rocks_grass"];
+const tDirt = "medit_dirt";
+const tDirtGrass = "medit_dirt_b";
+const tDirtCliff = "medit_cliff_italia";
+const tGrassCliff = "medit_cliff_italia_grass";
+const tCliff = ["medit_cliff_italia", "medit_cliff_italia", "medit_cliff_italia_grass"];
+const tForestFloor = "forestfloor_medit_dirt";
+// gaia entities
+const oBeech = "gaia/flora_tree_euro_beech";
+const oBerryBush = "gaia/flora_bush_berry";
+const oCarob = "gaia/flora_tree_carob";
+const oCypress1 = "gaia/flora_tree_cypress";
+const oCypress2 = "gaia/flora_tree_cypress";
+const oLombardyPoplar = "gaia/flora_tree_poplar_lombardy";
+const oOak = "gaia/flora_tree_oak";
+const oPalm = "gaia/flora_tree_medit_fan_palm";
+const oPine = "gaia/flora_tree_aleppo_pine";
+const oPoplar = "gaia/flora_tree_poplar";
+const oSheep = "gaia/fauna_sheep";
+const oStone = "gaia/geology_stone_greek";
+const oMetal = "gaia/geology_metal_greek";
+// decorative props
+const aBushLargeDry = "actor|props/flora/bush_medit_la_dry.xml";
+const aBushLarge = "actor|props/flora/bush_medit_la.xml";
+const aBushMedDry = "actor|props/flora/bush_medit_me_dry.xml";
+const aBushMed = "actor|props/flora/bush_medit_me.xml";
+const aBushSmall = "actor|props/flora/bush_medit_sm.xml";
+const aBushSmallDry = "actor|props/flora/bush_medit_sm_dry.xml";
+const aGrass = "actor|props/flora/grass_medit_field.xml";
+const aGrassDry = "actor|props/flora/grass_soft_dry_small.xml";
+const aRockLarge = "actor|geology/stone_granite_greek_large.xml";
+const aRockMed = "actor|geology/stone_granite_greek_med.xml";
+const aRockSmall = "actor|geology/stone_granite_greek_small.xml";
+const aWaterLog = "actor|props/flora/water_log.xml";
+// forests - we have the option of specifying terrain and tree type in one string, using TERRAIN_SEPARATOR
+var tPalmForest = [tForestFloor+TERRAIN_SEPARATOR+oPalm, tGrass];
+var tPineForest = [tForestFloor+TERRAIN_SEPARATOR+oPine, tGrass];
+var tMainForest = [tForestFloor+TERRAIN_SEPARATOR+oCarob, tForestFloor+TERRAIN_SEPARATOR+oBeech, tGrass, tGrass];
+var tPoplarForest = [tForestFloor+TERRAIN_SEPARATOR+oLombardyPoplar, tGrass];
+// Initialize world
+log("Initializing map...");
+var numPlayers = getNumPlayers();
+var mapSize = getMapSize();
+// Create classes
+var clWater = createTileClass();
+var clCliff = createTileClass();
+var clForest = createTileClass();
+var clMetal = createTileClass();
+var clStone = createTileClass();
+var clFood = createTileClass();
+var clPlayer = createTileClass();
+var clBaseResource = createTileClass();
+// Place players
+log("Placing players...");
+var playerX = new Array(numPlayers+1);
+var playerY = new Array(numPlayers+1);
+var numLeftPlayers = floor(numPlayers/2);
+for (var i=1; i <= numLeftPlayers; i++)
+{
+    playerX[i] = 0.28 + (2*randFloat()-1)*0.01;
+    playerY[i] = (0.5+i-1)/numLeftPlayers + (2*randFloat()-1)*0.01;
+}
+for (var i=numLeftPlayers+1; i <= numPlayers; i++)
+{
+    playerX[i] = 0.72 + (2*randFloat()-1)*0.01;
+    playerY[i] = (0.5+i-numLeftPlayers-1)/numLeftPlayers + (2*randFloat()-1)*0.01;
+}
+for (var i=1; i <= numPlayers; i++)
+{
+    log("Creating base for player " + i + "...");
+    // get fractional locations in tiles
+    var ix = round(fractionToTiles(playerX[i]));
+    var iy = round(fractionToTiles(playerY[i]));
+    addToClass(ix, iy, clPlayer);
+    // create TC and starting units
+    // TODO: Get civ specific starting units
+    var civ = getCivCode(i - 1);
+    placeObject("structures/"+civ + "_civil_centre", i, ix, iy, PI*3/4);
+    var group = new SimpleGroup(
+        [new SimpleObject("units/"+civ+"_support_female_citizen", 3,3, 5,5)],
+        true, null, ix, iy
+    );
+    createObjectGroup(group, i);
+    // create starting berry bushes
+    var bbAngle = randFloat()*2*PI;
+    var bbDist = 9;
+    var bbX = round(ix + bbDist * cos(bbAngle));
+    var bbY = round(iy + bbDist * sin(bbAngle));
+    group = new SimpleGroup(
+        [new SimpleObject(oBerryBush, 5,5, 0,2)],
+        true, clBaseResource, bbX, bbY
+    );
+    createObjectGroup(group, 0);
+    // create starting mines
+    var mAngle = bbAngle;
+    while(abs(mAngle - bbAngle) < PI/3) {
+        mAngle = randFloat()*2*PI;
+    }
+    var mDist = 9;
+    var mX = round(ix + mDist * cos(mAngle));
+    var mY = round(iy + mDist * sin(mAngle));
+    group = new SimpleGroup(
+        [new SimpleObject(oStone, 2,2, 0,3),
+        new SimpleObject(oMetal, 2,2, 0,3)],
+        true, clBaseResource, mX, mY
+    );
+    createObjectGroup(group, 0);
+    // create starting straggler trees
+    group = new SimpleGroup(
+        [new SimpleObject(oPalm, 3,3, 7,10)],
+        true, clBaseResource, ix, iy
+    );
+    createObjectGroup(group, 0, avoidClasses(clBaseResource,2));
+}
+function distanceToPlayers(x, y)
+{
+    var r = 10000;
+    for (var i=1; i <= numPlayers; i++)
+    {
+        var dx = x - playerX[i];
+        var dy = y - playerY[i];
+        r = min(r, dx*dx + dy*dy);
+    }
+    return sqrt(r);
+}
+function playerNearness(x, y)
+{
+    var d = fractionToTiles(distanceToPlayers(x,y));
+    if (d < 13)
+        return 0;
+    else if (d < 19)
+        return (d-13)/(19-13);
+    else
+        return 1;
+}
+// Paint elevation
+log("Painting elevation...");
+var noise0 = new Noise2D(4 * mapSize/128);
+var noise1 = new Noise2D(8 * mapSize/128);
+var noise2 = new Noise2D(15 * mapSize/128);
+var noise2a = new Noise2D(20 * mapSize/128);
+var noise2b = new Noise2D(35 * mapSize/128);
+var noise3 = new Noise2D(4 * mapSize/128);
+var noise4 = new Noise2D(6 * mapSize/128);
+var noise5 = new Noise2D(11 * mapSize/128);
+for (var ix=0; ix<=mapSize; ix++)
+{
+    for (var iy=0; iy<=mapSize; iy++)
+    {
+        var x = ix / (mapSize + 1.0);
+        var y = iy / (mapSize + 1.0);
+        var pn = playerNearness(x, y);
+        var h = 0;
+        var distToWater = 0;
+        h = 32 * (x - 0.5);
+        // add the rough shape of the water
+        if (x < WATER_WIDTH)
+        {
+            h = max(-16.0, -28.0*(WATER_WIDTH-x)/WATER_WIDTH);
+        }
+        else if (x > 1.0-WATER_WIDTH)
+        {
+            h = max(-16.0, -28.0*(x-(1.0-WATER_WIDTH))/WATER_WIDTH);
+        }
+        else
+        {
+            distToWater = (0.5 - WATER_WIDTH - abs(x-0.5));
+            var u = 1 - abs(x-0.5) / (0.5-WATER_WIDTH);
+            h = 12*u;
+        }
+        // add some base noise
+        var baseNoise = 16*noise0.get(x,y) + 8*noise1.get(x,y) + 4*noise2.get(x,y) - (16+8+4)/2;
+        if ( baseNoise < 0 )
+        {
+            baseNoise *= pn;
+            baseNoise *= max(0.1, distToWater / (0.5-WATER_WIDTH));
+        }
+        var oldH = h;
+        h += baseNoise;
+        // add some higher-frequency noise on land
+        if ( oldH > 0 )
+        {
+            h += (0.4*noise2a.get(x,y) + 0.2*noise2b.get(x,y)) * min(oldH/10.0, 1.0);
+        }
+        // create cliff noise
+        if ( h > -10 )
+        {
+            var cliffNoise = (noise3.get(x,y) + 0.5*noise4.get(x,y)) / 1.5;
+            if (h < 1)
+            {
+                var u = 1 - 0.3*((h-1)/-10);
+                cliffNoise *= u;
+            }
+            cliffNoise += 0.05 * distToWater / (0.5 - WATER_WIDTH);
+            if (cliffNoise > 0.6)
+            {
+                var u = 0.8 * (cliffNoise - 0.6);
+                cliffNoise += u * noise5.get(x,y);
+                cliffNoise /= (1 + u);
+            }
+            cliffNoise -= 0.59;
+            cliffNoise *= pn;
+            if (cliffNoise > 0)
+            {
+                h += 19 * min(cliffNoise, 0.045) / 0.045;
+            }
+        }
+        // set the height
+        setHeight(ix, iy, h);
+    }
+}
+// Paint base terrain
+log("Painting terrain...");
+var noise6 = new Noise2D(10 * mapSize/128);
+var noise7 = new Noise2D(20 * mapSize/128);
+var noise8 = new Noise2D(13 * mapSize/128);
+var noise9 = new Noise2D(26 * mapSize/128);
+var noise10 = new Noise2D(50 * mapSize/128);
+for (var ix=0; ix<mapSize; ix++)
+{
+    for (var iy=0; iy<mapSize; iy++)
+    {
+        var x = ix / (mapSize + 1.0);
+        var y = iy / (mapSize + 1.0);
+        var pn = playerNearness(x, y);
+        // get heights of surrounding vertices
+        var h00 = getHeight(ix, iy);
+        var h01 = getHeight(ix, iy+1);
+        var h10 = getHeight(ix+1, iy);
+        var h11 = getHeight(ix+1, iy+1);
+        // find min and max height
+        var maxH = Math.max(h00, h01, h10, h11);
+        var minH = Math.min(h00, h01, h10, h11);
+        // figure out if we're at the top of a cliff using min adjacent height
+        var minAdjHeight = minH;
+        if (maxH > 15)
+        {
+            var maxNx = min(ix+2, mapSize);
+            var maxNy = min(iy+2, mapSize);
+            for (var nx=max(ix-1, 0); nx <= maxNx; nx++)
+            {
+                for (var ny=max(iy-1, 0); ny <= maxNy; ny++)
+                {
+                    minAdjHeight = min(minAdjHeight, getHeight(nx, ny));
+                }
+            }
+        }
+        // choose a terrain based on elevation
+        var t = tGrass;
+        // water
+        if (maxH < -12)
+        {
+            t = tOceanDepths;
+        }
+        else if (maxH < -8.8)
+        {
+            t = tOceanRockDeep;
+        }
+        else if (maxH < -4.7)
+        {
+            t = tOceanCoral;
+        }
+        else if (maxH < -2.8)
+        {
+            t = tOceanRockShallow;
+        }
+        else if (maxH < 0.9 && minH < 0.35)
+        {
+            t = tBeachWet;
+        }
+        else if (maxH < 1.5 && minH < 0.9)
+        {
+            t = tBeachDry;
+        }
+        else if (maxH < 2.3 && minH < 1.3)
+        {
+            t = tBeachGrass;
+        }
+        if (minH < 0)
+        {
+            addToClass(ix, iy, clWater);
+        }
+        // cliffs
+        if (maxH - minH > 2.9 && minH > -7)
+        {
+            t = tCliff;
+            addToClass(ix, iy, clCliff);
+        }
+        else if ((maxH - minH > 2.5 && minH > -5) || (maxH-minAdjHeight > 2.9 && minH > 0) )
+        {
+            if (minH < -1)
+                t = tCliff;
+            else if (minH < 0.5)
+                t = tBeachCliff;
+            else
+                t = [tDirtCliff, tGrassCliff, tGrassCliff, tGrassRock, tCliff];
+            addToClass(ix, iy, clCliff);
+        }
+        // forests
+        if (maxH - minH < 1 && minH > 1)
+        {
+            var forestNoise = (noise6.get(x,y) + 0.5*noise7.get(x,y)) / 1.5 * pn;
+            forestNoise -= 0.59;
+            if (forestNoise > 0)
+            {
+                if (minH > 5)
+                {
+                    var typeNoise = noise10.get(x,y);
+                    if (typeNoise < 0.43 && forestNoise < 0.05)
+                        t = tPoplarForest;
+                    else if (typeNoise < 0.63)
+                        t = tMainForest;
+                    else
+                        t = tPineForest;
+                    addToClass(ix, iy, clForest);
+                }
+                else if (minH < 3)
+                {
+                    t = tPalmForest;
+                    addToClass(ix, iy, clForest);
+                }
+            }
+        }
+        // grass variations
+        if (t == tGrass)
+        {
+            var grassNoise = (noise8.get(x,y) + 0.6*noise9.get(x,y)) / 1.6;
+            if (grassNoise < 0.3)
+            {
+                t = (maxH - minH > 1.2) ? tDirtCliff : tDirt;
+            }
+            else if (grassNoise < 0.34)
+            {
+                t = (maxH - minH > 1.2) ? tGrassCliff : tGrassDry;
+                if (maxH - minH < 0.5 && randFloat() < 0.03)
+                {
+                    placeObject(aGrassDry, 0, ix+randFloat(), iy+randFloat(), randFloat()*2*PI);
+                }
+            }
+            else if (grassNoise > 0.61)
+            {
+                t = ((maxH - minH) > 1.2 ? tGrassRock : tGrassShrubs);
+            }
+            else
+            {
+                if ((maxH - minH) < 0.5 && randFloat() < 0.05)
+                {
+                    placeObject(aGrass, 0, ix+randFloat(), iy+randFloat(), randFloat()*2*PI);
+                }
+            }
+        }
+        placeTerrain(ix, iy, t);
+    }
+}
+log("Placing straggler trees...");
+// create straggler trees
+var trees = [oCarob, oBeech, oLombardyPoplar, oLombardyPoplar, oPine];
+for (var t in trees)
+{
+    group = new SimpleGroup([new SimpleObject(trees[t], 1,1, 0,1)], true, clForest);
+    createObjectGroups(group, 0,
+        avoidClasses(clWater, 5, clCliff, 0, clForest, 1, clPlayer, 15),
+        mapSize*mapSize/7000, 50
+    );
+}
+log("Placing cypress trees...");
+// create cypresses
+group = new SimpleGroup(
+    [new SimpleObject(oCypress2, 1,3, 0,3),
+    new SimpleObject(oCypress1, 0,2, 0,2)]
+);
+createObjectGroups(group, 0,
+    avoidClasses(clWater, 4, clCliff, 2, clForest, 1, clPlayer, 15),
+    mapSize*mapSize/3500, 50
+);
+log("Placing bushes...");
+// create bushes
+group = new SimpleGroup(
+    [new SimpleObject(aBushSmall, 0,2, 0,2), new SimpleObject(aBushSmallDry, 0,2, 0,2),
+    new SimpleObject(aBushMed, 0,1, 0,2), new SimpleObject(aBushMedDry, 0,1, 0,2)]
+);
+createObjectGroups(group, 0,
+    avoidClasses(clWater, 4, clCliff, 2),
+    mapSize*mapSize/1800, 50
+);
+log("Placing rocks...");
+// create rocks
+group = new SimpleGroup(
+    [new SimpleObject(aRockSmall, 0,3, 0,2), new SimpleObject(aRockMed, 0,2, 0,2),
+    new SimpleObject(aRockLarge, 0,1, 0,2)]
+);
+createObjectGroups(group, 0,
+    avoidClasses(clWater, 0, clCliff, 0),
+    mapSize*mapSize/1800, 50
+);
+log("Placing stone mines...");
+// create stone
+group = new SimpleGroup([new SimpleObject(oStone, 2,3, 0,2)], true, clStone);
+createObjectGroups(group, 0,
+    [avoidClasses(clWater, 0, clForest, 0, clPlayer, 20, clStone, 15),
+     new BorderTileClassConstraint(clCliff, 0, 5)],
+* numPlayers, 100
+);
+log("Placing metal mines...");
+// create metal
+group = new SimpleGroup([new SimpleObject(oMetal, 2,3, 0,2)], true, clMetal);
+createObjectGroups(group, 0,
+    [avoidClasses(clWater, 0, clForest, 0, clPlayer, 20, clMetal, 15, clStone, 5),
+     new BorderTileClassConstraint(clCliff, 0, 5)],
+* numPlayers, 100
+);
+log("Placing sheep...");
+// create sheep
+group = new SimpleGroup([new SimpleObject(oSheep, 2,4, 0,2)], true, clFood);
+createObjectGroups(group, 0,
+    avoidClasses(clWater, 5, clForest, 1, clCliff, 1, clPlayer, 20, clMetal, 2, clStone, 2, clFood, 8),
+* numPlayers, 100
+);
+log("Placing berry bushes...");
+// create berry bushes
+group = new SimpleGroup([new SimpleObject(oBerryBush, 5,7, 0,3)], true, clFood);
+createObjectGroups(group, 0,
+    avoidClasses(clWater, 5, clForest, 1, clCliff, 1, clPlayer, 20, clMetal, 2, clStone, 2, clFood, 8),
+.5 * numPlayers, 100
+);

binaries/data/mods/public/maps/random/latium.json

Property changes on: binaries\data\mods\public\maps\random\latium.js
___________________________________________________________________
Added: svn:eol-style
   + native

+{
+    "settings" : {
+        "Name" : "Latium",
+        "Script" : "latium.js",
+        "Description" : "A test of the Latium script",
+        "BaseTerrain" : ["medit_grass_field", "medit_grass_field_a", "medit_grass_flowers"],
+        "BaseHeight" : 0,
+        "RevealMap": true,
+        "GameType": "endless",
+        "XXXXXX" : "Optionally define other things here, like we would for a scenario"
+    }
+}
+ No newline at end of file

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

Property changes on: binaries\data\mods\public\maps\random\latium.json
___________________________________________________________________
Added: svn:eol-style
   + native

-// constants
-const SIZE = 208;
-const NUM_PLAYERS = 4;
-const tSand = "desert_rough";
-const tDunes = "desert_wave";
-const tFineSand = "desert_sahara";
-const tCliff = "cliff_desert";
-const tForest = "grass_sand_75|flora/trees/palm_b.xml";
-const tGrassSand75 = "grass_sand_75";
-const tGrassSand50 = "grass_sand_50";
-const tGrassSand25 = "grass_sand_25_2";
-const tDirt = "dirt_hard";
-const tDirtCracks = "dirt_cracks";
-const tShore = "sand";
-const tWater = "water_2";
-const tWaterDeep = "water_3";
-const oTree = "flora/trees/palm_b.xml";
-const oBerryBush = "flora_bush_berry";
-const oBush = "props/flora/bush_dry_a.xml";
-const oSheep = "fauna_sheep";
-const oDeer = "fauna_deer";
-const oMine = "geology_stone_light";
-const oDecorativeRock = "geology/gray1.xml";
-// some utility functions to save typing
-function paintClass(cl) {
-    return new TileClassPainter(cl);
+}
-function avoidClasses(/*class1, dist1, class2, dist2, etc*/) {
-    var ar = new Array(arguments.length/2);
-    for(var i=0; i<arguments.length/2; i++) {
-        ar[i] = new AvoidTileClassConstraint(arguments[2*i], arguments[2*i+1]);
+    }
-    return ar;
+}
-// initialize map
-println("Initializing map...");
-init(SIZE, tSand, 10);
-// create tile classes
-clPlayer = createTileClass();
-clHill1 = createTileClass();
-clHill2 = createTileClass();
-clHill3 = createTileClass();
-clForest = createTileClass();
-clWater = createTileClass();
-clPatch = createTileClass();
-clRock = createTileClass();
-clFood = createTileClass();
-clBaseResource = createTileClass();
-// place players
-playerX = new Array(NUM_PLAYERS);
-playerY = new Array(NUM_PLAYERS);
-playerAngle = new Array(NUM_PLAYERS);
-startAngle = randFloat() * 2 * PI;
-for(i=0; i<NUM_PLAYERS; i++) {
-    playerAngle[i] = startAngle + i*2*PI/NUM_PLAYERS;
-    playerX[i] = 0.5 + 0.39*cos(playerAngle[i]);
-    playerY[i] = 0.5 + 0.39*sin(playerAngle[i]);
+}
-for(i=0; i<NUM_PLAYERS; i++) {
-    println("Creating base for player " + i + "...");
-    // some constants
-    radius = 20;
-    cliffRadius = 2;
-    elevation = 30;
-    // get the x and y in tiles
-    fx = fractionToTiles(playerX[i]);
-    fy = fractionToTiles(playerY[i]);
-    ix = round(fx);
-    iy = round(fy);
-    // calculate size based on the radius
-    size = PI * radius * radius;
-    // create the hill
-    placer = new ClumpPlacer(size, 0.9, 0.5, 0, ix, iy);
-    createArea(placer, paintClass(clPlayer), null);
-    // create the central road patch
-    placer = new ClumpPlacer(PI*2*2, 0.6, 0.3, 0.5, ix, iy);
-    painter = new TerrainPainter(tDirt);
-    createArea(placer, painter, null);
-    // create the TC and the villies
-    group = new SimpleGroup(
-        [                           // elements (type, count, distance)
-            new SimpleObject("hele_civil_centre", 1,1, 0,0),
-            new SimpleObject("hele_infantry_spearman_b", 3,3, 5,5)
-        ],
-        true, null, ix, iy
-    );
-    createObjectGroup(group, i);
-    // create berry bushes
-    bbAngle = randFloat()*2*PI;
-    bbDist = 10;
-    bbX = round(fx + bbDist * cos(bbAngle));
-    bbY = round(fy + bbDist * sin(bbAngle));
-    group = new SimpleGroup(
-        [new SimpleObject(oSheep, 5,5, 0,2)],
-        true, clBaseResource,   bbX, bbY
-    );
-    createObjectGroup(group, 0);
-    // create mines
-    mAngle = bbAngle;
-    while(abs(mAngle - bbAngle) < PI/3) {
-        mAngle = randFloat()*2*PI;
+    }
-    mDist = 12;
-    mX = round(fx + mDist * cos(mAngle));
-    mY = round(fy + mDist * sin(mAngle));
-    group = new SimpleGroup(
-        [new SimpleObject(oMine, 3,3, 0,2)],
-        true, clBaseResource,   mX, mY
-    );
-    createObjectGroup(group, 0);
-    // create starting straggler trees
-    group = new SimpleGroup(
-        [new SimpleObject(oTree, 2,2, 6,12)],
-        true, null, ix, iy
-    );
-    createObjectGroup(group, 0, avoidClasses(clBaseResource,1));
+}
-// create patches
-println("Creating sand patches...");
-placer = new ClumpPlacer(30, 0.2, 0.1, 0);
-painter = new LayeredPainter([1], [[tSand, tFineSand], tFineSand]);
-createAreas(placer, [painter, paintClass(clPatch)],
-    avoidClasses(clPatch, 5),
-    (SIZE*SIZE)/600
-);
-println("Creating dirt patches...");
-placer = new ClumpPlacer(10, 0.2, 0.1, 0);
-painter = new TerrainPainter([tSand, tDirt]);
-createAreas(placer, [painter, paintClass(clPatch)],
-    avoidClasses(clPatch, 5),
-    (SIZE*SIZE)/600
-);
-// create the oasis
-println("Creating water...");
-placer = new ClumpPlacer(1200, 0.6, 0.1, 0, SIZE/2, SIZE/2);
-painter = new LayeredPainter([6,1], [[tSand, tForest], tShore, tWaterDeep]);
-elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, -10, 5);
-createArea(placer, [painter, elevationPainter, paintClass(clForest)], null);
-// create hills
-println("Creating level 1 hills...");
-placer = new ClumpPlacer(150, 0.25, 0.1, 0.3);
-terrainPainter = new LayeredPainter(
-    [1],                // widths
-    [tCliff, tSand]     // terrains
-);
-elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, 16, 1);
-createAreas(placer, [terrainPainter, elevationPainter, paintClass(clHill1)],
-    avoidClasses(clForest, 2, clPlayer, 0, clHill1, 16),
-    (SIZE*SIZE)/3800, 100
-);
-println("Creating small level 1 hills...");
-placer = new ClumpPlacer(60, 0.25, 0.1, 0.3);
-terrainPainter = new LayeredPainter(
-    [1],                // widths
-    [tCliff, tSand]     // terrains
-);
-elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, 16, 1);
-createAreas(placer, [terrainPainter, elevationPainter, paintClass(clHill1)],
-    avoidClasses(clForest, 2, clPlayer, 0, clHill1, 3),
-    (SIZE*SIZE)/2800, 100
-);
-println("Creating level 2 hills...");
-placer = new ClumpPlacer(60, 0.2, 0.1, 0.9);
-terrainPainter = new LayeredPainter(
-    [1],                // widths
-    [tCliff, tSand]     // terrains
-);
-elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, 16, 1);
-createAreas(placer, [terrainPainter, elevationPainter, paintClass(clHill2)],
-    [avoidClasses(clHill2, 1), new StayInTileClassConstraint(clHill1, 0)],
-    (SIZE*SIZE)/2800, 200
-);
-println("Creating level 3 hills...");
-placer = new ClumpPlacer(25, 0.2, 0.1, 0.9);
-terrainPainter = new LayeredPainter(
-    [1],                // widths
-    [tCliff, tSand]     // terrains
-);
-elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, 16, 1);
-createAreas(placer, [terrainPainter, elevationPainter, paintClass(clHill3)],
-    [avoidClasses(clHill3, 1), new StayInTileClassConstraint(clHill2, 0)],
-    (SIZE*SIZE)/9000, 300
-);
-// create forests
-println("Creating forests...");
-placer = new ClumpPlacer(25, 0.15, 0.1, 0.3);
-painter = new TerrainPainter([tSand, tForest]);
-createAreas(placer, [painter, paintClass(clForest)],
-    avoidClasses(clWater, 0, clPlayer, 1, clForest, 20, clHill1, 0),
-    (SIZE*SIZE)/4000, 50
-);
-// create mines
-println("Creating mines...");
-group = new SimpleGroup([new SimpleObject(oMine, 4,6, 0,2)], true, clRock);
-createObjectGroups(group, 0,
-    [avoidClasses(clWater, 2, clForest, 2, clPlayer, 0, clRock, 13),
-     new BorderTileClassConstraint(clHill1, 0, 4)],
-    (SIZE*SIZE)/4000, 100
-);
-// create decorative rocks for hills
-println("Creating decorative rocks...");
-group = new SimpleGroup([new SimpleObject(oDecorativeRock, 1,1, 0,0)], true);
-createObjectGroups(group, 0,
-    new BorderTileClassConstraint(clHill1, 0, 3),
-    (SIZE*SIZE)/2000, 100
-);
-// create deer
-println("Creating deer...");
-group = new SimpleGroup([new SimpleObject(oDeer, 5,7, 0,4)], true, clFood);
-createObjectGroups(group, 0,
-    avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill1, 0, clFood, 25),
-    (SIZE*SIZE)/5000, 50
-);
-// create sheep
-println("Creating sheep...");
-group = new SimpleGroup([new SimpleObject(oSheep, 1,3, 0,2)], true, clFood);
-createObjectGroups(group, 0,
-    avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill1, 0, clFood, 15),
-    (SIZE*SIZE)/5000, 50
-);
-// create straggler trees
-println("Creating straggler trees...");
-group = new SimpleGroup([new SimpleObject(oTree, 1,1, 0,0)], true);
-createObjectGroups(group, 0,
-    avoidClasses(clWater, 0, clForest, 0, clHill1, 0, clPlayer, 0),
-    SIZE*SIZE/1500
-);
-// create bushes
-println("Creating bushes...");
-group = new SimpleGroup([new SimpleObject(oBush, 2,3, 0,2)]);
-createObjectGroups(group, 0,
-    avoidClasses(clWater, 3, clHill1, 0, clPlayer, 0, clForest, 0),
-    SIZE*SIZE/1000
-);
-// create bushes
-println("Creating more decorative rocks...");
-group = new SimpleGroup([new SimpleObject(oDecorativeRock, 1,2, 0,2)]);
-createObjectGroups(group, 0,
-    avoidClasses(clWater, 3, clHill1, 0, clPlayer, 0, clForest, 0),
-    SIZE*SIZE/1000
-);
- No newline at end of file

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

+// terrain textures
+const tSand = "desert_dirt_rough";
+const tDunes = "desert_sand_dunes_100";
+const tFineSand = "desert_sand_smooth";
+const tCliff = "desert_cliff_badlands";
+const tGrassSand75 = "desert_grass_a";
+const tGrassSand50 = "desert_grass_a_sand";
+const tGrassSand25 = "desert_grass_a_stones";
+const tDirt = "desert_dirt_rough";
+const tDirtCracks = "desert_dirt_cracks";
+const tShore = "desert_sand_wet";
+const tWater = "desert_shore_stones";
+const tWaterDeep = "desert_shore_stones_wet";
+// gaia entities
+const oBerryBush = "gaia/flora_bush_berry";
+const oSheep = "gaia/fauna_sheep";
+const oDeer = "gaia/fauna_deer";
+const oMine = "gaia/geology_stone_desert_small";
+const oTree = "gaia/flora_tree_medit_fan_palm";
+// decorative props
+const aBush = "actor|props/flora/bush_dry_a.xml";
+const aDecorativeRock = "actor|geology/gray1.xml";
+var tForest = tGrassSand75 + TERRAIN_SEPARATOR + oTree;
+// initialize map
+log("Initializing map...");
+var numPlayers = getNumPlayers();
+var mapSize = getMapSize();
+// create tile classes
+var clPlayer = createTileClass();
+var clHill1 = createTileClass();
+var clHill2 = createTileClass();
+var clHill3 = createTileClass();
+var clForest = createTileClass();
+var clWater = createTileClass();
+var clPatch = createTileClass();
+var clRock = createTileClass();
+var clFood = createTileClass();
+var clBaseResource = createTileClass();
+// place players
+var playerX = new Array(numPlayers);
+var playerY = new Array(numPlayers);
+var playerAngle = new Array(numPlayers);
+var startAngle = randFloat() * 2 * PI;
+for (var i=0; i < numPlayers; i++)
+{
+    playerAngle[i] = startAngle + i*2*PI/numPlayers;
+    playerX[i] = 0.5 + 0.39*cos(playerAngle[i]);
+    playerY[i] = 0.5 + 0.39*sin(playerAngle[i]);
+}
+for (var i=0; i < numPlayers; i++)
+{
+    log("Creating base for player " + (i + 1) + "...");
+    // some constants
+    var radius = 20;
+    // get the x and y in tiles
+    var fx = fractionToTiles(playerX[i]);
+    var fy = fractionToTiles(playerY[i]);
+    var ix = round(fx);
+    var iy = round(fy);
+    // calculate size based on the radius
+    var size = PI * radius * radius;
+    // create the hill
+    log("Creating hill for player " + (i + 1) + "...");
+    var placer = new ClumpPlacer(size, 0.9, 0.5, 0, ix, iy);
+    createArea(placer, paintClass(clPlayer), null);
+    // create the central road patch
+    log("Creating central road for player " + (i + 1) + "...");
+    placer = new ClumpPlacer(PI*2*2, 0.6, 0.3, 0.5, ix, iy);
+    var painter = new TerrainPainter(tDirt);
+    createArea(placer, painter, null);
+    // create the TC and citizens
+    log("Creating TC/citizens for player " + (i + 1) + "...");
+    var civ = getCivCode(i);
+    var group = new SimpleGroup(
+        [                           // elements (type, count, distance)
+            new SimpleObject("structures/"+civ+"_civil_centre", 1,1, 0,0),
+            new SimpleObject("units/"+civ+"_support_female_citizen", 3,3, 5,5)
+        ],
+        true, null, ix, iy
+    );
+    createObjectGroup(group, i+1);
+    // create berry bushes
+    log("Creating berry bushes for player " + (i + 1) + "...");
+    var bbAngle = randFloat()*2*PI;
+    var bbDist = 10;
+    var bbX = round(fx + bbDist * cos(bbAngle));
+    var bbY = round(fy + bbDist * sin(bbAngle));
+    group = new SimpleGroup(
+        [new SimpleObject(oSheep, 5,5, 0,2)],
+        true, clBaseResource,   bbX, bbY
+    );
+    createObjectGroup(group, 0);
+    // create mines
+    log("Creating mines for player " + (i + 1) + "...");
+    var mAngle = bbAngle;
+    while(abs(mAngle - bbAngle) < PI/3) {
+        mAngle = randFloat()*2*PI;
+    }
+    var mDist = 12;
+    var mX = round(fx + mDist * cos(mAngle));
+    var mY = round(fy + mDist * sin(mAngle));
+    group = new SimpleGroup(
+        [new SimpleObject(oMine, 3,3, 0,2)],
+        true, clBaseResource,   mX, mY
+    );
+    createObjectGroup(group, 0);
+    // create starting straggler trees
+    log("Creating trees for player " + (i + 1) + "...");
+    group = new SimpleGroup(
+        [new SimpleObject(oTree, 2,2, 6,12)],
+        true, null, ix, iy
+    );
+    createObjectGroup(group, 0, avoidClasses(clBaseResource,1));
+}
+// create patches
+log("Creating sand patches...");
+var placer = new ClumpPlacer(30, 0.2, 0.1, 0);
+var painter = new LayeredPainter([[tSand, tFineSand], tFineSand], [1]);
+createAreas(placer, [painter, paintClass(clPatch)],
+    avoidClasses(clPatch, 5),
+    (mapSize*mapSize)/600
+);
+log("Creating dirt patches...");
+placer = new ClumpPlacer(10, 0.2, 0.1, 0);
+painter = new TerrainPainter([tSand, tDirt]);
+createAreas(placer, [painter, paintClass(clPatch)],
+    avoidClasses(clPatch, 5),
+    (mapSize*mapSize)/600
+);
+// create the oasis
+log("Creating water...");
+placer = new ClumpPlacer(1200, 0.6, 0.1, 0, mapSize/2, mapSize/2);
+painter = new LayeredPainter([[tSand, tForest], tShore, tWaterDeep], [6,1]);
+elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, -10, 5);
+createArea(placer, [painter, elevationPainter, paintClass(clForest)], null);
+// create hills
+log("Creating level 1 hills...");
+placer = new ClumpPlacer(150, 0.25, 0.1, 0.3);
+var terrainPainter = new LayeredPainter(
+    [tCliff, tSand],        // terrains
+    [1]             // widths
+);
+var elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, 16, 1);
+createAreas(placer, [terrainPainter, elevationPainter, paintClass(clHill1)],
+    avoidClasses(clForest, 2, clPlayer, 0, clHill1, 16),
+    (mapSize*mapSize)/3800, 100
+);
+log("Creating small level 1 hills...");
+placer = new ClumpPlacer(60, 0.25, 0.1, 0.3);
+terrainPainter = new LayeredPainter(
+    [tCliff, tSand],        // terrains
+    [1]             // widths
+);
+elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, 16, 1);
+createAreas(placer, [terrainPainter, elevationPainter, paintClass(clHill1)],
+    avoidClasses(clForest, 2, clPlayer, 0, clHill1, 3),
+    (mapSize*mapSize)/2800, 100
+);
+log("Creating level 2 hills...");
+placer = new ClumpPlacer(60, 0.2, 0.1, 0.9);
+terrainPainter = new LayeredPainter(
+    [tCliff, tSand],        // terrains
+    [1]             // widths
+);
+elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, 16, 1);
+createAreas(placer, [terrainPainter, elevationPainter, paintClass(clHill2)],
+    [avoidClasses(clHill2, 1), new StayInTileClassConstraint(clHill1, 0)],
+    (mapSize*mapSize)/2800, 200
+);
+log("Creating level 3 hills...");
+placer = new ClumpPlacer(25, 0.2, 0.1, 0.9);
+terrainPainter = new LayeredPainter(
+    [tCliff, tSand],        // terrains
+    [1]             // widths
+);
+elevationPainter = new SmoothElevationPainter(ELEVATION_MODIFY, 16, 1);
+createAreas(placer, [terrainPainter, elevationPainter, paintClass(clHill3)],
+    [avoidClasses(clHill3, 1), new StayInTileClassConstraint(clHill2, 0)],
+    (mapSize*mapSize)/9000, 300
+);
+// create forests
+log("Creating forests...");
+placer = new ClumpPlacer(25, 0.15, 0.1, 0.3);
+painter = new TerrainPainter([tSand, tForest]);
+createAreas(placer, [painter, paintClass(clForest)],
+    avoidClasses(clWater, 0, clPlayer, 1, clForest, 20, clHill1, 0),
+    (mapSize*mapSize)/4000, 50
+);
+// create mines
+log("Creating mines...");
+group = new SimpleGroup([new SimpleObject(oMine, 4,6, 0,2)], true, clRock);
+createObjectGroups(group, 0,
+    [avoidClasses(clWater, 2, clForest, 2, clPlayer, 0, clRock, 13),
+     new BorderTileClassConstraint(clHill1, 0, 4)],
+    (mapSize*mapSize)/4000, 100
+);
+// create decorative rocks for hills
+log("Creating decorative rocks...");
+group = new SimpleGroup([new SimpleObject(aDecorativeRock, 1,1, 0,0)], true);
+createObjectGroups(group, undefined,
+    new BorderTileClassConstraint(clHill1, 0, 3),
+    (mapSize*mapSize)/2000, 100
+);
+// create deer
+log("Creating deer...");
+group = new SimpleGroup([new SimpleObject(oDeer, 5,7, 0,4)], true, clFood);
+createObjectGroups(group, 0,
+    avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill1, 0, clFood, 25),
+    (mapSize*mapSize)/5000, 50
+);
+// create sheep
+log("Creating sheep...");
+group = new SimpleGroup([new SimpleObject(oSheep, 1,3, 0,2)], true, clFood);
+createObjectGroups(group, 0,
+    avoidClasses(clWater, 0, clForest, 0, clPlayer, 0, clHill1, 0, clFood, 15),
+    (mapSize*mapSize)/5000, 50
+);
+// create straggler trees
+log("Creating straggler trees...");
+group = new SimpleGroup([new SimpleObject(oTree, 1,1, 0,0)], true);
+createObjectGroups(group, 0,
+    avoidClasses(clWater, 0, clForest, 0, clHill1, 0, clPlayer, 0),
+    mapSize*mapSize/1500
+);
+// create bushes
+log("Creating bushes...");
+group = new SimpleGroup([new SimpleObject(aBush, 2,3, 0,2)]);
+createObjectGroups(group, undefined,
+    avoidClasses(clWater, 3, clHill1, 0, clPlayer, 0, clForest, 0),
+    mapSize*mapSize/1000
+);
+// create bushes
+log("Creating more decorative rocks...");
+group = new SimpleGroup([new SimpleObject(aDecorativeRock, 1,2, 0,2)]);
+createObjectGroups(group, undefined,
+    avoidClasses(clWater, 3, clHill1, 0, clPlayer, 0, clForest, 0),
+    mapSize*mapSize/1000
+);
+ No newline at end of file

binaries/data/mods/public/maps/random/neareastern_badlands.json

Property changes on: binaries\data\mods\public\maps\random\neareastern_badlands.js
___________________________________________________________________
Added: svn:eol-style
   + native

+{
+    "settings" : {
+        "Name" : "Neareastern Badlands",
+        "Script" : "neareastern_badlands.js",
+        "Description" : "A test of the Neareastern Badlands script",
+        "BaseTerrain" : "desert_rough",
+        "BaseHeight" : 10,
+        "RevealMap": true,
+        "GameType": "endless",
+        "XXXXXX" : "Optionally define other things here, like we would for a scenario"
+    }
+}
+ No newline at end of file

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

Property changes on: binaries\data\mods\public\maps\random\neareastern_badlands.json
___________________________________________________________________
Added: svn:eol-style
   + native


	1	// New format RMS test
	2
	3

binaries/data/mods/public/maps/random/new_rms_test.json

Property changes on: binaries\data\mods\public\maps\random\new_rms_test.js
___________________________________________________________________
Added: svn:eol-style
   + native

+{
+    "settings" : {
+        "Name" : "New RMS Test",
+        "Script" : "new_rms_test.js",
+        "Description" : "A test of the new integrated random map generator!",
+        "BaseTerrain" : "grass1_spring",
+        "BaseHeight" : 0,
+        "RevealMap": true,
+        "GameType": "endless",
+        "XXXXXX" : "Optionally define other things here, like we would for a scenario"
+    }
+}
+ No newline at end of file

source/graphics/Entity.h

Property changes on: binaries\data\mods\public\maps\random\new_rms_test.json
___________________________________________________________________
Added: svn:eol-style
   + native

+/* Copyright (C) 2010 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 <http://www.gnu.org/licenses/>.
+ */
+#ifndef INCLUDED_ENTITY
+#define INCLUDED_ENTITY
+// Struct for parsing random map data
+struct Entity
+{
+    std::wstring templateName;
+    u16 entityID;
+    u16 playerID;
+    float positionX;
+    float positionZ;
+    float orientationY;
+    bool isActor;
+};
+#endif
+ No newline at end of file

source/graphics/MapGenerator.cpp

Property changes on: source\graphics\Entity.h
___________________________________________________________________
Added: svn:eol-style
   + native

+/* Copyright (C) 2010 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 <http://www.gnu.org/licenses/>.
+ */
+#include "precompiled.h"
+#include "MapGenerator.h"
+#include "lib/timer.h"
+#include "ps/CLogger.h"
+#define LOG_CATEGORY L"graphics"
+namespace MapGenRNG
+{
+    boost::mt19937 g_RNG;
+    static JSFunctionSpec global_functions[] = {
+        JS_FS("seedRand",   SeedRand,   1, 0),
+        JS_FS("randInt",  RandInt,  1, 0),
+        JS_FS("randFloat", RandFloat, 0, 0),
+        JS_FS_END
+    };
+}//namespace MapGenRNG
+CMapGenerator::CMapGenerator() : m_ScriptInterface("Generator")
+{
+    // Register global functions
+    JSObject* globalObj = JSVAL_TO_OBJECT(m_ScriptInterface.GetGlobalObject());
+    if (!JS_DefineFunctions(m_ScriptInterface.GetContext(), globalObj, MapGenRNG::global_functions))
+    {
+        LOGERROR(L"GenerateMap: Error defining global functions");
+    }
+    // load mapgen libraries
+    LoadLibraries();
+}
+CScriptValRooted CMapGenerator::GenerateMap(const CStrW& scriptFile, const CScriptValRooted& settings)
+{
+    TIMER(L"GenerateMap");
+    // Init map generator
+    jsval global = m_ScriptInterface.GetGlobalObject();
+    if (!m_ScriptInterface.CallFunctionVoid(global, "InitMapGen", settings))
+    {
+        LOGERROR(L"GenerateMap: Error calling 'InitMapGen' library function");
+        return CScriptValRooted();
+    }
+    // Load RMS
+    // Check for blank file, this allows creating blank terrains
+    if (scriptFile.length())
+    {
+        LoadScript(scriptFile);
+    }
+    // Run save function
+    CScriptValRooted ret;
+    if (!m_ScriptInterface.CallFunction(global, "SaveMap", ret))
+    {
+        LOGERROR(L"GenerateMap: Error calling 'SaveMap' library function");
+        return CScriptValRooted();
+    }
+    return ret;
+}
+void CMapGenerator::LoadLibraries()
+{
+    VfsPaths pathnames;
+    // Load all scripts in mapgen directory
+    if (fs_util::GetPathnames(g_VFS, VfsPath(L"maps/mapgen/"), L"*.js", pathnames) < 0)
+        LOGERROR(L"Error reading scripts in directory: maps/mapgen/");
+    for (VfsPaths::iterator it = pathnames.begin(); it != pathnames.end(); ++it)
+    {
+        LoadScript(it->string());
+    }
+}
+CScriptValRooted CMapGenerator::LoadScript(const std::wstring& filename)
+{
+    LOGMESSAGE(L"Loading map generator script '%ls'", filename.c_str());
+    VfsPath path(filename);
+    if (!FileExists(g_VFS, path))
+    {
+        LOGERROR(L"Script file '%ls' does not exist", filename.c_str());
+        return CScriptValRooted();
+    }
+    CVFSFile file;
+    PSRETURN ret = file.Load(g_VFS, path);
+    if (ret != PSRETURN_OK)
+    {
+        LOGERROR(L"Failed to load script '%ls': %hs", filename.c_str(), GetErrorString(ret));
+        return CScriptValRooted();
+    }
+    CScriptValRooted retVal;
+    if (!m_ScriptInterface.Eval(file.GetAsString().c_str(), retVal))
+    {
+        LOGERROR(L"Failed to eval script '%ls'", filename.c_str());
+        return CScriptValRooted();
+    }
+    return retVal;
+}
+ScriptInterface& CMapGenerator::GetScriptInterface()
+{
+    return m_ScriptInterface;
+}
+//////////////////////////////////////////////////////////////////////////////
+JSBool MapGenRNG::SeedRand(JSContext *cx, uintN argc, jsval *vp)
+{
+    uint32 seed = 0;
+    if (!JS_ConvertArguments(cx, argc, JS_ARGV(cx, vp), "/u", &seed))
+    {
+        JS_ReportError(cx, "seedRand() cannot convert argument to integer");
+        return JS_FALSE;
+    }
+    g_RNG.seed(seed);
+    JS_SET_RVAL(cx, vp, JSVAL_VOID);  /* return undefined */
+    return JS_TRUE;
+}
+JSBool MapGenRNG::RandInt(JSContext *cx, uintN argc, jsval *vp)
+{
+    int32 min, max, result;
+    if (argc == 1)
+    {
+        if (!JS_ConvertArguments(cx, argc, JS_ARGV(cx, vp), "/i", &max))
+        {
+            JS_ReportError(cx, "randInt() cannot convert argument to integer");
+            return JS_FALSE;
+        }
+        result = randInt(max);
+    }
+    else if (argc == 2)
+    {
+        if (!JS_ConvertArguments(cx, argc, JS_ARGV(cx, vp), "/i/i", &min, &max))
+        {
+            JS_ReportError(cx, "randInt() cannot convert arguments to integers");
+            return JS_FALSE;
+        }
+        result = min + randInt(max - min + 1);
+    }
+    else
+    {
+        JS_ReportError(cx, "randInt() received invalid number of arguments: %u", argc);
+        return JS_FALSE;
+    }
+    JS_SET_RVAL(cx, vp, INT_TO_JSVAL(result));
+    return JS_TRUE;
+}
+JSBool MapGenRNG::RandFloat(JSContext *cx, uintN argc, jsval *vp)
+{
+    float min, max, result;
+    if (argc == 0)
+    {
+        result = randFloat();
+    }
+    else if (argc == 2)
+    {
+        if (!JS_ConvertArguments(cx, argc, JS_ARGV(cx, vp), "/d/d", &min, &max))
+        {
+            JS_ReportError(cx, "randFloat() cannot convert arguments to doubles");
+            return JS_FALSE;
+        }
+        result = min + randFloat() * (max - min);
+    }
+    else
+    {
+        JS_ReportError(cx, "randFloat() received invalid number of arguments: %u", argc);
+        return JS_FALSE;
+    }
+    JS_SET_RVAL(cx, vp, DOUBLE_TO_JSVAL(result));
+    return JS_TRUE;
+}
+int32 MapGenRNG::randInt(int32 max)
+{
+    return g_RNG() % max;
+}
+float MapGenRNG::randFloat()
+{
+    return float(g_RNG()) * (1.0f/4294967296.0f);
+}

source/graphics/MapGenerator.h

Property changes on: source\graphics\MapGenerator.cpp
___________________________________________________________________
Added: svn:eol-style
   + native

+/* Copyright (C) 2010 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 <http://www.gnu.org/licenses/>.
+ */
+#ifndef INCLUDED_MAPGENERATOR
+#define INCLUDED_MAPGENERATOR
+#include "lib/res/handle.h"
+#include "ps/CStr.h"
+#include "ps/FileIo.h"
+#include "scriptinterface/ScriptInterface.h"
+#include "js/jsapi.h"
+#include <boost/random/mersenne_twister.hpp>
+class CMapGenerator
+{
+public:
+    // constructor
+    CMapGenerator();
+    CScriptValRooted GenerateMap(const CStrW& scriptFile, const CScriptValRooted& settings);
+    ScriptInterface& GetScriptInterface();
+private:
+    void LoadLibraries();
+    CScriptValRooted LoadScript(const std::wstring& filename);
+    ScriptInterface m_ScriptInterface;
+};
+namespace MapGenRNG
+{
+    JSBool SeedRand(JSContext *cx, uintN argc, jsval *vp);
+    JSBool RandInt(JSContext *cx, uintN argc, jsval *vp);
+    JSBool RandFloat(JSContext *cx, uintN argc, jsval *vp);
+    int32 randInt(int32 max);
+    float randFloat();
+}//namespace MapGenRNG
+#endif
+ No newline at end of file

source/graphics/MapReader.cpp

Property changes on: source\graphics\MapGenerator.h
___________________________________________________________________
Added: svn:eol-style
   + native

 #include "graphics/Camera.h"
 #include "graphics/CinemaTrack.h"
+#include "graphics/Entity.h"
 #include "graphics/GameView.h"
+#include "graphics/MapGenerator.h"
 #include "graphics/Patch.h"
 #include "graphics/Terrain.h"
 #include "graphics/TerrainTextureEntry.h"
 …
     RegMemFun(this, &CMapReader::DelayLoadFinished, L"CMapReader::DelayLoadFinished", 5);
+}
+// LoadRandomMap: try to load the map data; reinitialise the scene to new data if successful
+void CMapReader::LoadRandomMap(const CStrW& scriptFile, const CScriptValRooted& settings, CTerrain *pTerrain_,
+                         WaterManager* pWaterMan_, SkyManager* pSkyMan_,
+                         CLightEnv *pLightEnv_, CGameView *pGameView_, CCinemaManager* pCinema_, CTriggerManager* pTrigMan_,
+                         CSimulation2 *pSimulation2_, int playerID_)
+{
+    // latch parameters (held until DelayedLoadFinished)
+    m_ScriptFile = scriptFile;
+    m_ScriptSettings = settings;
+    pTerrain = pTerrain_;
+    pLightEnv = pLightEnv_;
+    pGameView = pGameView_;
+    pWaterMan = pWaterMan_;
+    pSkyMan = pSkyMan_;
+    pCinema = pCinema_;
+    pTrigMan = pTrigMan_;
+    pSimulation2 = pSimulation2_;
+    m_PlayerID = playerID_;
+    m_CameraStartupTarget = INVALID_ENTITY;
+    // delete all existing entities
+    if (pSimulation2)
+        pSimulation2->ResetState();
+    only_xml = false;
+    // copy random map settings (before entity creation)
+    RegMemFun(this, &CMapReader::LoadRMSettings, L"CMapReader::LoadRMSettings", 50);
+    // load player settings script (must be done before reading map)
+    RegMemFun(this, &CMapReader::LoadPlayerSettings, L"CMapReader::LoadPlayerSettings", 50);
+    // load map generator with random map script
+    RegMemFun(this, &CMapReader::GenerateMap, L"CMapReader::GenerateMap", 2000);
+    // parse RMS results into terrain structure
+    RegMemFun(this, &CMapReader::ParseTerrain, L"CMapReader::ParseTerrain", 500);
+    // parse RMS results into environment settings
+    RegMemFun(this, &CMapReader::ParseEnvironment, L"CMapReader::ParseEnvironment", 5);
+    // parse RMS results into camera settings
+    RegMemFun(this, &CMapReader::ParseCamera, L"CMapReader::ParseCamera", 5);
+    // parse RMS results into entities
+    RegMemFun(this, &CMapReader::ParseEntities, L"CMapReader::ParseEntities", 1000);
+    // apply data to the world
+    RegMemFun(this, &CMapReader::ApplyData, L"CMapReader::ApplyData", 5);
+    // load map settings script (must be done after reading map)
+    RegMemFun(this, &CMapReader::LoadMapSettings, L"CMapReader::LoadMapSettings", 5);
+    RegMemFun(this, &CMapReader::DelayLoadFinished, L"CMapReader::DelayLoadFinished", 5);
+}
 // UnpackMap: unpack the given data from the raw data stream into local variables
 int CMapReader::UnpackMap()
+{
 …
     return 0;
+}
+int CMapReader::LoadRMSettings()
+{
+    // copy random map settings over to sim
+    pSimulation2->SetMapSettings(m_ScriptSettings);
+    return 0;
+}
+int CMapReader::GenerateMap()
+{
+    CMapGenerator mapGen;
+    CStrW scriptPath;
+    if (m_ScriptFile.length())
+        scriptPath = L"maps/random/"+m_ScriptFile;
+    // Copy map settings from simulator to mapgen context
+    CScriptValRooted scriptSettings(mapGen.GetScriptInterface().GetContext(), mapGen.GetScriptInterface().CloneValueFromOtherContext(pSimulation2->GetScriptInterface(), m_ScriptSettings.get()));
+    CScriptValRooted mapData = mapGen.GenerateMap(scriptPath, scriptSettings);
+    // No map data, something bad happened
+    if(mapData.undefined())
+        throw PSERROR_File_ReadFailed("CMapReader::GenerateMap() failed to generate map");
+    // Copy data from mapgen to simulator context
+    m_MapData = CScriptValRooted(pSimulation2->GetScriptInterface().GetContext(), pSimulation2->GetScriptInterface().CloneValueFromOtherContext(mapGen.GetScriptInterface(), mapData.get()));
+    return 0;
+};
+int CMapReader::ParseTerrain()
+{
+    // TODO: Progressive loading
+    // parse terrain from map data
+#define GET_TERRAIN_PROPERTY(prop, out)\
+    if (!pSimulation2->GetScriptInterface().GetProperty(m_MapData.get(), #prop, out))\
+        LOGERROR(L"CMapReader::ParseTerrain() failed to get '%hs' property", #prop);\
+    size_t size;
+    GET_TERRAIN_PROPERTY(size, size)
+    m_PatchesPerSide = size / PATCH_SIZE;
+    // flat heightmap of u16 data
+    GET_TERRAIN_PROPERTY(height, m_Heightmap)
+    // load textures
+    GET_TERRAIN_PROPERTY(numTextures, num_terrain_tex)
+    std::vector<std::string> textureNames;
+    GET_TERRAIN_PROPERTY(textureNames, textureNames)
+    while (cur_terrain_tex < num_terrain_tex)
+    {
+        debug_assert(CTerrainTextureManager::IsInitialised()); // we need this for the terrain properties (even when graphics are disabled)
+        CTerrainTextureEntry* texentry = g_TexMan.FindTexture(textureNames[cur_terrain_tex]);
+        m_TerrainTextures.push_back(texentry);
+        cur_terrain_tex++;
+        //LDR_CHECK_TIMEOUT(cur_terrain_tex, num_terrain_tex);
+    }
+    // build tile data
+    m_Tiles.resize(SQR(size));
+    std::vector<u16> tileData;
+    GET_TERRAIN_PROPERTY(tileData, tileData)
+    size_t i;
+    CMapIO::STileDesc tileDesc = {0, 0xFFFF, 0};
+    for (i = 0; i < tileData.size(); ++i)
+    {
+        tileDesc.m_Tex1Index = tileData[i];
+        m_Tiles[i] = tileDesc;
+    }
+    // reset generator state
+    cur_terrain_tex = 0;
+#undef GET_TERRAIN_PROPERTY
+    return 0;
+}
+int CMapReader::ParseEntities()
+{
+    // parse entities from map data
+    std::vector<Entity> entities;
+    if (!pSimulation2->GetScriptInterface().GetProperty(m_MapData.get(), "entities", entities))
+        LOGWARNING(L"CMapReader::ParseEntities() failed to get 'entities' property");
+    size_t entity_idx = 0;
+    size_t num_entities = entities.size();
+    Entity currEnt;
+    while (entity_idx < num_entities)
+    {
+        // Get current entity struct
+        currEnt = entities[entity_idx];
+        entity_id_t ent = pSimulation2->AddEntity(currEnt.templateName, currEnt.entityID);
+        // Check that entity was added
+        if (ent == INVALID_ENTITY)
+        {
+            LOGERROR(L"Failed to load entity template '%ls'", currEnt.templateName.c_str());
+        }
+        else
+        {
+            CmpPtr<ICmpPosition> cmpPosition(*pSimulation2, ent);
+            if (!cmpPosition.null())
+            {
+                cmpPosition->JumpTo(entity_pos_t::FromFloat(currEnt.positionX), entity_pos_t::FromFloat(currEnt.positionZ));
+                cmpPosition->SetYRotation(entity_angle_t::FromFloat(currEnt.orientationY));
+                // TODO: other parts of the position
+            }
+            CmpPtr<ICmpOwnership> cmpOwner(*pSimulation2, ent);
+            if (!cmpOwner.null())
+                cmpOwner->SetOwner(currEnt.playerID);
+            if (boost::algorithm::ends_with(currEnt.templateName, L"civil_centre"))
+            {
+                // HACK: we special-case civil centre files to initialise the camera.
+                // This ought to be based on a more generic mechanism for indicating
+                // per-player camera start locations.
+                if (m_CameraStartupTarget == INVALID_ENTITY && currEnt.playerID == m_PlayerID && !cmpPosition.null())
+                    m_CameraStartupTarget = ent;
+            }
+        }
+        entity_idx++;
+    }
+    return 0;
+}
+int CMapReader::ParseEnvironment()
+{
+    // parse environment settings from map data
+#define GET_ENVIRONMENT_PROPERTY(val, prop, out)\
+    if (!pSimulation2->GetScriptInterface().GetProperty(val, #prop, out))\
+        LOGWARNING(L"CMapReader::ParseEnvironment() failed to get '%hs' property", #prop);\
+    CScriptValRooted envObj;
+    GET_ENVIRONMENT_PROPERTY(m_MapData.get(), Environment, envObj)
+    if (envObj.undefined())
+    {
+        LOGWARNING(L"CMapReader::ParseEnvironment(): Environment settings not found");
+        return 0;
+    }
+    std::wstring skySet;
+    GET_ENVIRONMENT_PROPERTY(envObj.get(), SkySet, skySet)
+    pSkyMan->SetSkySet(skySet);
+    GET_ENVIRONMENT_PROPERTY(envObj.get(), SunColour, m_LightEnv.m_SunColor)
+    GET_ENVIRONMENT_PROPERTY(envObj.get(), SunElevation, m_LightEnv.m_Elevation)
+    GET_ENVIRONMENT_PROPERTY(envObj.get(), SunRotation, m_LightEnv.m_Rotation)
+    GET_ENVIRONMENT_PROPERTY(envObj.get(), TerrainAmbientColour, m_LightEnv.m_TerrainAmbientColor)
+    GET_ENVIRONMENT_PROPERTY(envObj.get(), UnitsAmbientColour, m_LightEnv.m_UnitsAmbientColor)
+    // Water properties
+    CScriptValRooted waterObj;
+    GET_ENVIRONMENT_PROPERTY(envObj.get(), Water, waterObj)
+    CScriptValRooted waterBodyObj;
+    GET_ENVIRONMENT_PROPERTY(waterObj.get(), WaterBody, waterBodyObj)
+    // Water level - necessary
+    float waterHeight;
+    GET_ENVIRONMENT_PROPERTY(waterBodyObj.get(), Height, waterHeight)
+    CmpPtr<ICmpWaterManager> cmpWaterMan(*pSimulation2, SYSTEM_ENTITY);
+    debug_assert(!cmpWaterMan.null());
+    cmpWaterMan->SetWaterLevel(entity_pos_t::FromFloat(waterHeight));
+    // If we have graphics, get rest of settings
+    if (pWaterMan)
+    {
+        std::wstring waterType;
+        // TODO: Water type unimplemented
+        //GET_ENVIRONMENT_PROPERTY(waterBodyObj.get(), Type, waterType)
+        RGBColor waterColour;
+        GET_ENVIRONMENT_PROPERTY(waterBodyObj.get(), Colour, waterColour)
+        pWaterMan->m_WaterColor = CColor(waterColour.X, waterColour.Y, waterColour.Z, 1.0f);
+        GET_ENVIRONMENT_PROPERTY(waterBodyObj.get(), Shininess, pWaterMan->m_Shininess)
+        GET_ENVIRONMENT_PROPERTY(waterBodyObj.get(), Waviness, pWaterMan->m_Waviness)
+        GET_ENVIRONMENT_PROPERTY(waterBodyObj.get(), Murkiness, pWaterMan->m_Murkiness)
+        RGBColor waterTint;
+        GET_ENVIRONMENT_PROPERTY(waterBodyObj.get(), Tint, waterTint)
+        pWaterMan->m_WaterTint = CColor(waterTint.X, waterTint.Y, waterTint.Z, 1.0f);
+        RGBColor reflectTint;
+        GET_ENVIRONMENT_PROPERTY(waterBodyObj.get(), ReflectionTint, reflectTint)
+        pWaterMan->m_ReflectionTint = CColor(reflectTint.X, reflectTint.Y, reflectTint.Z, 1.0f);
+        GET_ENVIRONMENT_PROPERTY(waterBodyObj.get(), ReflectionTintStrength, pWaterMan->m_ReflectionTintStrength)
+    }
+    m_LightEnv.CalculateSunDirection();
+#undef GET_ENVIRONMENT_PROPERTY
+    return 0;
+}
+int CMapReader::ParseCamera()
+{
+    // parse camera settings from map data
+    // defaults if we don't find camera
+    float declination = DEGTORAD(30.f), rotation = DEGTORAD(-45.f);
+    CVector3D translation = CVector3D(100, 150, -100);
+#define GET_CAMERA_PROPERTY(val, prop, out)\
+    if (!pSimulation2->GetScriptInterface().GetProperty(val, #prop, out))\
+        LOGWARNING(L"CMapReader::ParseCamera() failed to get '%hs' property", #prop);\
+    CScriptValRooted cameraObj;
+    GET_CAMERA_PROPERTY(m_MapData.get(), Camera, cameraObj)
+    if (!cameraObj.undefined())
+    {   // If camera property exists, read values
+        CFixedVector3D pos;
+        GET_CAMERA_PROPERTY(cameraObj.get(), Position, pos)
+        translation = pos;
+        GET_CAMERA_PROPERTY(cameraObj.get(), Rotation, rotation)
+        GET_CAMERA_PROPERTY(cameraObj.get(), Declination, declination)
+    }
+#undef GET_CAMERA_PROPERTY
+    if (pGameView)
+    {
+        pGameView->GetCamera()->m_Orientation.SetXRotation(declination);
+        pGameView->GetCamera()->m_Orientation.RotateY(rotation);
+        pGameView->GetCamera()->m_Orientation.Translate(translation);
+        pGameView->GetCamera()->UpdateFrustum();
+    }
+    return 0;
+}

source/graphics/MapReader.h

     // clean up everything used during delayed load
     int DelayLoadFinished();
+    // Copy random map settings over to sim
+    int LoadRMSettings();
+    // Generate random map
+    int GenerateMap();
+    // Parse script data into terrain
+    int ParseTerrain();
+    // Parse script data into entities
+    int ParseEntities();
+    // Parse script data into environment
+    int ParseEnvironment();
+    // Parse script data into camera
+    int ParseCamera();
     // size of map
     ssize_t m_PatchesPerSide;
     // heightmap for map
 …
     // startup script
     CStrW m_Script;
+    // random map data
+    CStrW m_ScriptFile;
+    CScriptValRooted m_ScriptSettings;
+    CScriptValRooted m_MapData;
     // state latched by LoadMap and held until DelayedLoadFinished
     CFileUnpacker unpacker;
     CTerrain* pTerrain;

source/ps/Game.cpp


144	144	}
145	145	else if (mapType == "random")
146	146	{
147		// TODO: Coming in another patch
	147	// Load random map attributes
	148	std::wstring scriptFile;
	149	CScriptValRooted settings;
	150
	151	m_Simulation2->GetScriptInterface().GetProperty(attribs.get(), "script", scriptFile);
	152	m_Simulation2->GetScriptInterface().GetProperty(attribs.get(), "settings", settings);
	153
	154	m_World->RegisterInit(scriptFile, settings, m_PlayerID);
148	155	}
149	156
150	157

source/ps/GameSetup/GameSetup.cpp

 static bool Autostart(const CmdLineArgs& args);
 void Init(const CmdLineArgs& args, int flags)
+void Init(const CmdLineArgs& args, int UNUSED(flags))
+{
     h_mgr_init();
 …
     ScriptInterface& scriptInterface = g_Game->GetSimulation2()->GetScriptInterface();
     CScriptValRooted attrs;
+    scriptInterface.Eval("({})", attrs);
+    scriptInterface.SetProperty(attrs.get(), "mapType", std::string("scenario"), false);
+    scriptInterface.SetProperty(attrs.get(), "map", std::string(autostartMap), false);
+    scriptInterface.Eval("({settings: { Size: 208, Seed: 0, BaseTerrain: 'grass1_spring', BaseHeight: 0, PlayerData: [{Civ:'hele'},{Civ:'hele'}], RevealMap: false, LockTeams: false, GameType: 'conquest' } })", attrs);
+    if (args.Has("autostart-random"))
+    {
+        scriptInterface.SetProperty(attrs.get(), "script", std::string(autostartMap), false);
+        scriptInterface.SetProperty(attrs.get(), "mapType", std::string("random"), false);
+    }
+    else
+    {
+        scriptInterface.SetProperty(attrs.get(), "map", std::string(autostartMap), false);
+        scriptInterface.SetProperty(attrs.get(), "mapType", std::string("scenario"), false);
+    }
     CScriptValRooted mpInitData;
     g_GUI->GetScriptInterface().Eval("({isNetworked:true, playerAssignments:{}})", mpInitData);

source/ps/World.cpp

+    }
+}
+void CWorld::RegisterInit(const CStrW& scriptFile, const CScriptValRooted& settings, int playerID)
+{
+    // If scriptFile is empty, a blank map will be generated using settings (no RMS run)
+    CMapReader* reader = 0;
+    try
+    {
+        reader = new CMapReader;
+        CTriggerManager* pTriggerManager = NULL;
+        reader->LoadRandomMap(scriptFile, settings, m_Terrain,
+            CRenderer::IsInitialised() ? g_Renderer.GetWaterManager() : NULL,
+            CRenderer::IsInitialised() ? g_Renderer.GetSkyManager() : NULL,
+            &g_LightEnv, m_pGame->GetView(),
+            m_pGame->GetView() ? m_pGame->GetView()->GetCinema() : NULL,
+            pTriggerManager, m_pGame->GetSimulation2(), playerID);
+            // fails immediately, or registers for delay loading
+    }
+    catch (PSERROR_File& err)
+    {
+        delete reader;
+        LOGERROR(L"Failed to generate random map %ls: %hs", scriptFile.c_str(), err.what());
+        throw PSERROR_Game_World_MapLoadFailed();
+    }
+}
 /**
  * Destructor.
+ *

source/ps/World.h

 #define INCLUDED_WORLD
 #include "ps/Errors.h"
+#include "scriptinterface/ScriptInterface.h"
 #ifndef ERROR_GROUP_GAME_DEFINED
 #define ERROR_GROUP_GAME_DEFINED
 …
     */
     void RegisterInit(const CStrW& mapFile, int playerID);
+    void RegisterInit(const CStrW& scriptFile, const CScriptValRooted& settings, int playerID);
     /**
      * Get the pointer to the terrain object.
+     *

source/scriptinterface/ScriptConversions.cpp

 #include "ps/utf16string.h"
 #include "ps/CLogger.h"
 #include "ps/CStr.h"
+#include "graphics/Color.h"
+#include "graphics/Entity.h"
 #include "js/jsapi.h"
 …
     return true;
+}
+template<> bool ScriptInterface::FromJSVal<u64>(JSContext* cx, jsval v, u64& out)
+{
+    uint32 ret;
+    WARN_IF_NOT(JSVAL_IS_NUMBER(v), v);
+    if (!JS_ValueToECMAUint32(cx, v, &ret))
+        return false;
+    out = ret;
+    return true;
+}
 template<> bool ScriptInterface::FromJSVal<u32>(JSContext* cx, jsval v, u32& out)
+{
     uint32 ret;
 …
     return true;
+}
+template<> bool ScriptInterface::FromJSVal<u16>(JSContext* cx, jsval v, u16& out)
+{
+    uint16 ret;
+    WARN_IF_NOT(JSVAL_IS_NUMBER(v), v);
+    if (!JS_ValueToUint16(cx, v, &ret))
+        return false;
+    out = ret;
+    return true;
+}
 // NOTE: we can't define a jsval specialisation, because that conflicts with integer types
 template<> bool ScriptInterface::FromJSVal<CScriptVal>(JSContext* UNUSED(cx), jsval v, CScriptVal& out)
+{
 …
+{
     return FromJSVal_vector(cx, v, out);
+}
+template<> bool ScriptInterface::FromJSVal<std::vector<u16> >(JSContext* cx, jsval v, std::vector<u16>& out)
+{
+    return FromJSVal_vector(cx, v, out);
+}
+template<> bool ScriptInterface::FromJSVal<std::vector<std::string> >(JSContext* cx, jsval v, std::vector<std::string>& out)
+{
+    return FromJSVal_vector(cx, v, out);
+}
+template<> bool ScriptInterface::FromJSVal<Entity>(JSContext* cx, jsval v, Entity& out)
+{
+    JSObject* obj;
+    if (!JS_ValueToObject(cx, v, &obj) || obj == NULL)
+        FAIL("Argument must be an object");
+    jsval name, id, player, x, z, orient, actor;
+    if(!JS_GetProperty(cx, obj, "isActor", &actor) || !FromJSVal(cx, actor, out.isActor))
+        FAIL("Failed to read Entity.isActor property");
+    if (!out.isActor)
+        if(!JS_GetProperty(cx, obj, "player", &player) || !FromJSVal(cx, player, out.playerID))
+            FAIL("Failed to read Entity.player property");
+    if (!JS_GetProperty(cx, obj, "name", &name) || !FromJSVal(cx, name, out.templateName))
+        FAIL("Failed to read Entity.name property");
+    if (!JS_GetProperty(cx, obj, "id", &id) || !FromJSVal(cx, id, out.entityID))
+        FAIL("Failed to read Entity.id property");
+    if (!JS_GetProperty(cx, obj, "x", &x) || !FromJSVal(cx, x, out.positionX))
+        FAIL("Failed to read Entity.x property");
+    if (!JS_GetProperty(cx, obj, "y", &z) || !FromJSVal(cx, z, out.positionZ))
+        FAIL("Failed to read Entity.y property");
+    if (!JS_GetProperty(cx, obj, "orientation", &orient) || !FromJSVal(cx, orient, out.orientationY))
+        FAIL("Failed to read Entity.orientation property");
+    return true;
+}
+template<> bool ScriptInterface::FromJSVal<std::vector<Entity> >(JSContext* cx, jsval v, std::vector<Entity>& out)
+{
+    return FromJSVal_vector(cx, v, out);
+}
+template<> bool ScriptInterface::FromJSVal<RGBColor>(JSContext* cx, jsval v, RGBColor& out)
+{
+    JSObject* obj;
+    if (!JS_ValueToObject(cx, v, &obj) || obj == NULL)
+        FAIL("Argument must be an object");
+    jsval r, g, b;
+    if (!JS_GetProperty(cx, obj, "r", &r) || !FromJSVal(cx, r, out.X))
+        FAIL("Failed to read RGBColor.r property");
+    if (!JS_GetProperty(cx, obj, "g", &g) || !FromJSVal(cx, g, out.Y))
+        FAIL("Failed to read RGBColor.g property");
+    if (!JS_GetProperty(cx, obj, "b", &b) || !FromJSVal(cx, b, out.Z))
+        FAIL("Failed to read RGBColor.b property");
+    return true;
+}
+ No newline at end of file

source/scriptinterface/ScriptInterface.cpp

 #include "valgrind.h"
 const int RUNTIME_SIZE = 16 * 1024 * 1024; // TODO: how much memory is needed?
+const int RUNTIME_SIZE = 32 * 1024 * 1024; // TODO: how much memory is needed?
 const int STACK_CHUNK_SIZE = 8192;
 #if ENABLE_SCRIPT_PROFILING
 …
                 | JSOPTION_VAROBJFIX // "recommended" (fixes variable scoping)
                 // Enable all the JIT features:
 //              | JSOPTION_JIT
+                | JSOPTION_JIT
 //              | JSOPTION_METHODJIT
 //              | JSOPTION_PROFILING
         );

Context Navigation

Ticket #658: RMS_JS_Implementation.2.patch

binaries/data/mods/public/gui/gamesetup/gamesetup.js

binaries/data/mods/public/maps/mapgen/area.js

binaries/data/mods/public/maps/mapgen/constraint.js

binaries/data/mods/public/maps/mapgen/library.js

binaries/data/mods/public/maps/mapgen/map.js

binaries/data/mods/public/maps/mapgen/mapgen.js

binaries/data/mods/public/maps/mapgen/noise.js

binaries/data/mods/public/maps/mapgen/painter.js

binaries/data/mods/public/maps/mapgen/placer.js

binaries/data/mods/public/maps/mapgen/point.js

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

binaries/data/mods/public/maps/mapgen/terrain.js

binaries/data/mods/public/maps/mapgen/tileclass.js

binaries/data/mods/public/maps/mapgen/vector.js

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

binaries/data/mods/public/maps/random/cantabrian_highlands.json

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

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

binaries/data/mods/public/maps/random/latium.json

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

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

binaries/data/mods/public/maps/random/neareastern_badlands.json

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

binaries/data/mods/public/maps/random/new_rms_test.json

source/graphics/Entity.h

source/graphics/MapGenerator.cpp

source/graphics/MapGenerator.h

source/graphics/MapReader.cpp

source/graphics/MapReader.h

source/ps/Game.cpp

source/ps/GameSetup/GameSetup.cpp

source/ps/World.cpp

source/ps/World.h

source/scriptinterface/ScriptConversions.cpp

source/scriptinterface/ScriptInterface.cpp

Download in other formats: