Ticket #658: RMS_JS_Implementation.patch

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

@@ -75 +75 @@
     
     // 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)
+{
+    this.points = (points !== undefined ? points : []);
+}

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

@@ +1 @@
+
+///////////////////////////////////////////////////////////////////////////
+//  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

@@ +1 @@
+
+// PI
+const PI = Math.PI;
+
+const SEA_LEVEL = 20.0;
+
+const TERRAIN_SEPARATOR = "|";
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+//  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(createSimpleTerrain(terrain[i]));
+        
+        return new RandomTerrain(terrainList);
+    }
+    else
+    {
+        return createSimpleTerrain(terrain);
+    }
+}
+
+function createSimpleTerrain(terrain)
+{
+    // 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]);
+    }
+}
+
+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

@@ +1 @@
+//////////////////////////////////////////////////////////////////////
+//  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
+    var size = this.size;
+    for (var i=0; i < size; ++i)
+    {
+        for (var j=0; j < size; ++j)
+        {
+            if (this.terrainObjects[i][j].length)
+                entities = entities.concat(this.terrainObjects[i][j]);
+        }
+    }
+    
+    // Now other objects
+    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;
+        var temp = e.x; // Somehow x = z, and y = x
+        e.x = 4*e.y;
+        e.y = 4*temp;
+        
+        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 i=0; i < mapSize; i++)
+    {
+        var di = i*mapSize;
+        
+        for (var j=0; j < mapSize; j++)
+        {
+            var intHeight = ((this.height[i][j] + SEA_LEVEL) * 256.0 / 0.35)|0; // floor
+            
+            if (intHeight > 65000)
+                intHeight = 65000;
+            else if (intHeight < 0)
+                intHeight = 0;
+            
+            height16[di + j] = 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
+    var tiles = new Array(size*size);
+    for (var i=0; i < size; i++)
+    {
+        var di = i*size;
+        for (var j=0; j < size; j++)
+        {
+            tiles[di + j] = this.texture[i][j];
+        }
+    }
+    data["tileData"] = tiles;
+    
+    return data;
+};

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

@@ +1 @@
+// TODO: Since there's only one map anyway, just use this global variable
+var g_Map;
+
+// Global RNG (Mersenne Twister)
+var g_MT;
+
+// Map settings - once initialized, has all the game setup data, including player array
+var g_MapSettings = {
+    Size : 208,
+    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: 601.962, y: 117.579, z: 471.135},
+    Rotation: 0,
+    Declination: 0.523599
+};
+
+function InitMapGen(settings)
+{
+    g_MT = new MersenneTwister19937();
+    
+    if (settings === undefined || settings == {})
+    {
+        warn("InitMapGen: settings missing");
+    }
+    else
+    {
+        g_MapSettings = settings;
+    }
+    
+    seedRand(g_MapSettings.Seed);
+
+    // Create new map
+    log("Creating new map...");
+    var terrain = createTerrain(g_MapSettings.BaseTerrain);
+    
+    g_Map = new Map(g_MapSettings.Size, 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/MersenneTwister19937.js

@@ +1 @@
+// this program is a JavaScript version of Mersenne Twister, with concealment and encapsulation in class,
+// an almost straight conversion from the original program, mt19937ar.c,
+// translated by y. okada on July 17, 2006.
+// and modified a little at july 20, 2006, but there are not any substantial differences.
+// in this program, procedure descriptions and comments of original source code were not removed.
+// lines commented with //c// were originally descriptions of c procedure. and a few following lines are appropriate JavaScript descriptions.
+// lines commented with /* and */ are original comments.
+// lines commented with // are additional comments in this JavaScript version.
+// before using this version, create at least one instance of MersenneTwister19937 class, and initialize the each state, given below in c comments, of all the instances.
+/*
+   A C-program for MT19937, with initialization improved 2002/1/26.
+   Coded by Takuji Nishimura and Makoto Matsumoto.
+
+   Before using, initialize the state by using init_genrand(seed)
+   or init_by_array(init_key, key_length).
+
+   Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
+   All rights reserved.
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions
+   are met:
+
+     1. Redistributions of source code must retain the above copyright
+        notice, this list of conditions and the following disclaimer.
+
+     2. Redistributions in binary form must reproduce the above copyright
+        notice, this list of conditions and the following disclaimer in the
+        documentation and/or other materials provided with the distribution.
+
+     3. The names of its contributors may not be used to endorse or promote
+        products derived from this software without specific prior written
+        permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+   Any feedback is very welcome.
+   http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
+   email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
+*/
+
+function MersenneTwister19937()
+{
+    /* Period parameters */
+    //c//#define N 624
+    //c//#define M 397
+    //c//#define MATRIX_A 0x9908b0dfUL   /* constant vector a */
+    //c//#define UPPER_MASK 0x80000000UL /* most significant w-r bits */
+    //c//#define LOWER_MASK 0x7fffffffUL /* least significant r bits */
+    const N = 624;
+    const M = 397;
+    const MATRIX_A = 0x9908b0df;   /* constant vector a */
+    const UPPER_MASK = 0x80000000; /* most significant w-r bits */
+    const LOWER_MASK = 0x7fffffff; /* least significant r bits */
+    //c//static unsigned long mt[N]; /* the array for the state vector  */
+    //c//static int mti=N+1; /* mti==N+1 means mt[N] is not initialized */
+    var mt = new Array(N);   /* the array for the state vector  */
+    var mti = N+1;           /* mti==N+1 means mt[N] is not initialized */
+
+    function unsigned32 (n1) // returns a 32-bits unsiged integer from an operand to which applied a bit operator.
+    {
+        return n1 < 0 ? (n1 ^ UPPER_MASK) + UPPER_MASK : n1;
+    }
+
+    function subtraction32 (n1, n2) // emulates lowerflow of a c 32-bits unsiged integer variable, instead of the operator -. these both arguments must be non-negative integers expressible using unsigned 32 bits.
+    {
+        return n1 < n2 ? unsigned32((0x100000000 - (n2 - n1)) & 0xffffffff) : n1 - n2;
+    }
+
+    function addition32 (n1, n2) // emulates overflow of a c 32-bits unsiged integer variable, instead of the operator +. these both arguments must be non-negative integers expressible using unsigned 32 bits.
+    {
+        return unsigned32((n1 + n2) & 0xffffffff)
+    }
+
+    function multiplication32 (n1, n2) // emulates overflow of a c 32-bits unsiged integer variable, instead of the operator *. these both arguments must be non-negative integers expressible using unsigned 32 bits.
+    {
+        var sum = 0;
+        for (var i = 0; i < 32; ++i){
+            if ((n1 >>> i) & 0x1){
+                sum = addition32(sum, unsigned32(n2 << i));
+            }
+        }
+        return sum;
+    }
+
+    /* initializes mt[N] with a seed */
+    //c//void init_genrand(unsigned long s)
+    this.init_genrand = function (s)
+    {
+        //c//mt[0]= s & 0xffffffff;
+        mt[0]= unsigned32(s & 0xffffffff);
+        for (mti=1; mti<N; mti++) {
+            mt[mti] = 
+            //c//(1812433253 * (mt[mti-1] ^ (mt[mti-1] >> 30)) + mti);
+            addition32(multiplication32(1812433253, unsigned32(mt[mti-1] ^ (mt[mti-1] >>> 30))), mti);
+            /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
+            /* In the previous versions, MSBs of the seed affect   */
+            /* only MSBs of the array mt[].                        */
+            /* 2002/01/09 modified by Makoto Matsumoto             */
+            //c//mt[mti] &= 0xffffffff;
+            mt[mti] = unsigned32(mt[mti] & 0xffffffff);
+            /* for >32 bit machines */
+        }
+    }
+
+    /* initialize by an array with array-length */
+    /* init_key is the array for initializing keys */
+    /* key_length is its length */
+    /* slight change for C++, 2004/2/26 */
+    //c//void init_by_array(unsigned long init_key[], int key_length)
+    this.init_by_array = function (init_key, key_length)
+    {
+        //c//int i, j, k;
+        var i, j, k;
+        //c//init_genrand(19650218);
+        this.init_genrand(19650218);
+        i=1; j=0;
+        k = (N>key_length ? N : key_length);
+        for (; k; k--) {
+            //c//mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * 1664525))
+            //c//   + init_key[j] + j; /* non linear */
+            mt[i] = addition32(addition32(unsigned32(mt[i] ^ multiplication32(unsigned32(mt[i-1] ^ (mt[i-1] >>> 30)), 1664525)), init_key[j]), j);
+            mt[i] = 
+            //c//mt[i] &= 0xffffffff; /* for WORDSIZE > 32 machines */
+            unsigned32(mt[i] & 0xffffffff);
+            i++; j++;
+            if (i>=N) { mt[0] = mt[N-1]; i=1; }
+            if (j>=key_length) j=0;
+        }
+        for (k=N-1; k; k--) {
+            //c//mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * 1566083941))
+            //c//- i; /* non linear */
+            mt[i] = subtraction32(unsigned32((dbg=mt[i]) ^ multiplication32(unsigned32(mt[i-1] ^ (mt[i-1] >>> 30)), 1566083941)), i);
+            //c//mt[i] &= 0xffffffff; /* for WORDSIZE > 32 machines */
+            mt[i] = unsigned32(mt[i] & 0xffffffff);
+            i++;
+            if (i>=N) { mt[0] = mt[N-1]; i=1; }
+        }
+        mt[0] = 0x80000000; /* MSB is 1; assuring non-zero initial array */
+    }
+
+    /* generates a random number on [0,0xffffffff]-interval */
+    //c//unsigned long genrand_int32(void)
+    this.genrand_int32 = function ()
+    {
+        //c//unsigned long y;
+        //c//static unsigned long mag01[2]={0x0UL, MATRIX_A};
+        var y;
+        var mag01 = new Array(0x0, MATRIX_A);
+        /* mag01[x] = x * MATRIX_A  for x=0,1 */
+
+        if (mti >= N) { /* generate N words at one time */
+            //c//int kk;
+            var kk;
+
+            if (mti == N+1)   /* if init_genrand() has not been called, */
+                //c//init_genrand(5489); /* a default initial seed is used */
+                this.init_genrand(5489); /* a default initial seed is used */
+
+            for (kk=0;kk<N-M;kk++) {
+                //c//y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
+                //c//mt[kk] = mt[kk+M] ^ (y >> 1) ^ mag01[y & 0x1];
+                y = unsigned32((mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK));
+                mt[kk] = unsigned32(mt[kk+M] ^ (y >>> 1) ^ mag01[y & 0x1]);
+            }
+            for (;kk<N-1;kk++) {
+                //c//y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
+                //c//mt[kk] = mt[kk+(M-N)] ^ (y >> 1) ^ mag01[y & 0x1];
+                y = unsigned32((mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK));
+                mt[kk] = unsigned32(mt[kk+(M-N)] ^ (y >>> 1) ^ mag01[y & 0x1]);
+            }
+            //c//y = (mt[N-1]&UPPER_MASK)|(mt[0]&LOWER_MASK);
+            //c//mt[N-1] = mt[M-1] ^ (y >> 1) ^ mag01[y & 0x1];
+            y = unsigned32((mt[N-1]&UPPER_MASK)|(mt[0]&LOWER_MASK));
+            mt[N-1] = unsigned32(mt[M-1] ^ (y >>> 1) ^ mag01[y & 0x1]);
+            mti = 0;
+        }
+
+        y = mt[mti++];
+
+        /* Tempering */
+        //c//y ^= (y >> 11);
+        //c//y ^= (y << 7) & 0x9d2c5680;
+        //c//y ^= (y << 15) & 0xefc60000;
+        //c//y ^= (y >> 18);
+        y = unsigned32(y ^ (y >>> 11));
+        y = unsigned32(y ^ ((y << 7) & 0x9d2c5680));
+        y = unsigned32(y ^ ((y << 15) & 0xefc60000));
+        y = unsigned32(y ^ (y >>> 18));
+
+        return y;
+    }
+
+    /* generates a random number on [0,0x7fffffff]-interval */
+    //c//long genrand_int31(void)
+    this.genrand_int31 = function ()
+    {
+        //c//return (genrand_int32()>>1);
+        return (this.genrand_int32()>>>1);
+    }
+
+    /* generates a random number on [0,1]-real-interval */
+    //c//double genrand_real1(void)
+    this.genrand_real1 = function ()
+    {
+        //c//return genrand_int32()*(1.0/4294967295.0);
+        return this.genrand_int32()*(1.0/4294967295.0);
+        /* divided by 2^32-1 */
+    }
+
+    /* generates a random number on [0,1)-real-interval */
+    //c//double genrand_real2(void)
+    this.genrand_real2 = function ()
+    {
+        //c//return genrand_int32()*(1.0/4294967296.0);
+        return this.genrand_int32()*(1.0/4294967296.0);
+        /* divided by 2^32 */
+    }
+
+    /* generates a random number on (0,1)-real-interval */
+    //c//double genrand_real3(void)
+    this.genrand_real3 = function ()
+    {
+        //c//return ((genrand_int32()) + 0.5)*(1.0/4294967296.0);
+        return ((this.genrand_int32()) + 0.5)*(1.0/4294967296.0);
+        /* divided by 2^32 */
+    }
+
+    /* generates a random number on [0,1) with 53-bit resolution*/
+    //c//double genrand_res53(void)
+    this.genrand_res53 = function ()
+    {
+        //c//unsigned long a=genrand_int32()>>5, b=genrand_int32()>>6;
+        var a=this.genrand_int32()>>>5, b=this.genrand_int32()>>>6;
+        return(a*67108864.0+b)*(1.0/9007199254740992.0);
+    }
+    /* These real versions are due to Isaku Wada, 2002/01/09 added */
+}

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

@@ +1 @@
+// 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/object.js

@@ +1 @@
+function Entity(name, player, x, y, angle)
+{
+    // Get unique ID
+    this.id = g_Map.getEntityID();
+    this.name = name;
+    
+    // Convert from tile coords to map coords
+    this.x = x;
+    this.y = y;
+    
+    if (player !== undefined)
+    {
+        this.player = player;
+        this.isActor = false;
+    }
+    else
+    {   // Actors  have no player ID
+        this.isActor = true;
+    }
+    
+    this.orientation = (angle !== undefined ? angle : 0);
+}

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

@@ +1 @@
+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] != 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;
+            
+            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] == 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] == 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

@@ +1 @@
+
+/////////////////////////////////////////////////////////////////////////////////////////
+//  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 + (1.0/Math.max(this.smoothness,1.0/intPerim))|0;   // floor
+    
+    if (ctrlPts > radius * 2 * PI)
+        ctrlPts = (radius * 2 * PI)|0 + 1;  // floor
+    
+    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 = xx|0;   // floor
+            var j = yy|0;
+            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(x|0, y|0)) // floor
+                    {
+                        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(resultObjs[i].x|0, resultObjs[i].y|0);   // floor
+        }
+    }
+    
+    return true;
+};
+

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

@@ +1 @@
+function Point(x, y)
+{
+    this.x = (x !== undefined ? x : 0);
+    this.y = (y !== undefined ? y : 0);
+}
+
+///////////////////////////////////////////////////////////
+//  PointMap: Hash table for keeping track of points
+
+//~ function PointMap(size)
+//~ {
+    //~ this.points = new Array(size);
+    //~ for (var i = 0; i < size; ++i)
+    //~ {
+        //~ this.points[i] = new Uint16Array(size);
+    //~ }
+//~ }
+
+//~ PointMap.prototype.get = function(pt)
+//~ {
+    //~ if (pt instanceof Point)
+        //~ return this.points[pt.x][pt.y];
+    //~ else
+        //~ return undefined;
+//~ };
+
+//~ PointMap.prototype.set = function(pt, val)
+//~ {
+    //~ if (pt instanceof Point)
+        //~ this.points[pt.x][pt.y] = val;
+//~ };
+
+//~ PointMap.prototype.add = function(pt, val)
+//~ {
+    //~ if (pt instanceof Point)
+        //~ this.points[pt.x][pt.y] += val;
+//~ };
+ No newline at end of file

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

@@ +1 @@
+
+function seedRand(s)
+{
+    g_MT.init_genrand(s);
+}
+
+function randFloat()
+{
+    if (arguments.length == 0)
+    {
+        return g_MT.genrand_real1();
+    }
+    else
+    {
+        var minVal = arguments[0];
+        var maxVal = arguments[1];
+        
+        return minVal + randFloat() * (maxVal - minVal);
+    }
+}
+
+function randInt()
+{   
+    if (arguments.length == 1)
+    {
+        var maxVal = arguments[0];
+        
+        return g_MT.genrand_int32()%maxVal;
+    }
+    else
+    {
+        var minVal = arguments[0];
+        var maxVal = arguments[1];
+        
+        return minVal + randInt(maxVal - minVal + 1);
+    }
+}
+

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

@@ +1 @@
+//////////////////////////////////////////////////////////////////////
+//  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

@@ +1 @@
+//////////////////////////////////////////////////////////////////////
+//  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 > 0; s = (s/2)|0)  // floor
+    {
+        this.vals[s + pos] += amt;
+        pos = (pos/2)|0;    // floor
+    }
+};
+
+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 + start)/i)|0];   // floor
+            start += i;
+        }
+    }
+    
+    // 
+    while(i)
+    {
+        if(start+i <= end)
+        {
+            ret += this.vals[((nn + start)/i)|0];   // floor
+            start += i;
+        }
+        i = (i/2)|0;    // floor
+    }
+    
+    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 = y|0;   // floor
+        if(iy >= 0 && iy < size)
+        {
+            var dy = y - cy;
+            var dx = Math.sqrt(radius*radius - dy*dy);
+            
+            var lowerX = (cx - dx)|0;   // floor
+            var upperX = (cx + dx)|0;   // floor
+            
+            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

@@ +1 @@
+/////////////////////////////////////////////////////////////////////
+//  Vector2D
+/////////////////////////////////////////////////////////////////////
+
+// TODO: Type errors if v not instanceof Vector classes
+
+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

@@ -1 @@
-// 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";
+// actor / 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 clSettlement = 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
@@ -92 +93 @@
     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);
@@ -106 +107 @@
     // 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
@@ -140 +132 @@
     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
@@ -161 +154 @@
     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),
-    2 * NUM_PLAYERS
+    2 * 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),
-    6 * NUM_PLAYERS
+    6 * 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)],
-    3 * NUM_PLAYERS, 100
+    3 * 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),
-    2 * NUM_PLAYERS, 50
+// create small decorative rocks
+log("Creating large decorative rocks...");
+group = new SimpleGroup(
+    [new SimpleObject(aRockMedium, 1,3, 0,1)],
+    true
 );
-
-// create small decorative rocks
-println("Creating large decorative rocks...");
-group = new SimpleGroup([new SimpleObject(oRockMedium, 1,3, 0,1)], true);
-createObjectGroups(group, 0,
+createObjectGroups(
+    group, undefined,
     avoidClasses(clForest, 0, clPlayer, 0, clHill, 0, clSettlement, 3),
-    SIZE*SIZE/1000, 50
+    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,
+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, clSettlement, 5),
-    SIZE*SIZE/2000, 50
+    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),
-    3 * NUM_PLAYERS, 50
+    3 * 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),
-    3 * NUM_PLAYERS, 50
+    3 * 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
+    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)],
-    10 * NUM_PLAYERS, 100
+    10 * numPlayers, 100
 );
-

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

@@ +1 @@
+{
+    "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

@@ -1 @@
-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),
-    2 * 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)],
-    3 * 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)],
-    3 * 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),
-    3 * 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),
-    1.5 * NUM_PLAYERS, 100
-);

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

@@ +1 @@
+const WATER_WIDTH = 0.2;
+
+// terrain textures
+var tOceanDepths = "medit_sea_depths";
+var tOceanRockDeep = "medit_sea_coral_deep";
+var tOceanRockShallow = "medit_rocks_wet";
+var tOceanCoral = "medit_sea_coral_plants";
+var tBeachWet = "medit_sand_wet";
+var tBeachDry = "medit_sand";
+var tBeachGrass = "beach_medit_grass_50";
+var tBeachCliff = "cliff_medit_beach";
+var tGrassDry = ["medit_grass_field_brown", "medit_grass_field_dry", "medit_grass_field_b"];
+var tGrass = ["medit_grass_field", "medit_grass_field_a", "medit_grass_flowers"];
+var tGrassLush = ["grass_temperate_dry_tufts", "medit_grass_flowers"];
+var tGrassShrubs = ["medit_grass_shrubs", "medit_grass_flowers"];
+var tGrassRock = ["medit_rocks_grass"];
+var tDirt = "medit_dirt";
+var tDirtGrass = "medit_dirt_b";
+var tDirtCliff = "medit_cliff_italia";
+var tGrassCliff = "medit_cliff_italia_grass";
+var tCliff = ["medit_cliff_italia", "medit_cliff_italia", "medit_cliff_italia_grass"];
+var tForestFloor = "forestfloor_medit_dirt";
+
+// gaia entities
+var oBeech = "gaia/flora_tree_euro_beech";
+var oBerryBush = "gaia/flora_bush_berry";
+var oCarob = "gaia/flora_tree_carob";
+var oCypress1 = "gaia/flora_tree_cypress";
+var oCypress2 = "gaia/flora_tree_cypress";
+var oLombardyPoplar = "gaia/flora_tree_poplar_lombardy";
+var oOak = "gaia/flora_tree_oak";
+var oPalm = "gaia/flora_tree_medit_fan_palm";
+var oPine = "gaia/flora_tree_aleppo_pine";
+var oPoplar = "gaia/flora_tree_poplar";
+var oSheep = "gaia/fauna_sheep";
+var oStone = "gaia/geology_stone_greek";
+var oMetal = "gaia/geology_metal_greek";
+
+// actor / props
+var aBushLargeDry = "actor|props/flora/bush_medit_la_dry.xml";
+var aBushLarge = "actor|props/flora/bush_medit_la.xml";
+var aBushMedDry = "actor|props/flora/bush_medit_me_dry.xml";
+var aBushMed = "actor|props/flora/bush_medit_me.xml";
+var aBushSmall = "actor|props/flora/bush_medit_sm.xml";
+var aBushSmallDry = "actor|props/flora/bush_medit_sm_dry.xml";
+var aGrass = "actor|props/flora/grass_medit_field.xml";
+var aGrassDry = "actor|props/flora/grass_soft_dry_small.xml";
+var aRockLarge = "actor|geology/stone_granite_greek_large.xml";
+var aRockMed = "actor|geology/stone_granite_greek_med.xml";
+var aRockSmall = "actor|geology/stone_granite_greek_small.xml";
+var 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();
+var clSettlement = 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)
+        {
+            for (var nx=max(ix-1, 0); nx<=min(ix+2, mapSize); nx++)
+            {
+                for (var ny=max(iy-1, 0); ny<=min(iy+2, mapSize); 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, clSettlement, 4, 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, clSettlement, 4, 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, clSettlement, 4), 
+     new BorderTileClassConstraint(clCliff, 0, 5)],
+    3 * 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, clSettlement, 4), 
+     new BorderTileClassConstraint(clCliff, 0, 5)],
+    3 * 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, clSettlement, 4),
+    3 * 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, clSettlement, 4),
+    1.5 * numPlayers, 100
+);

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

@@ +1 @@
+{
+    "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

@@ -1 @@
-// 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/new_rms_test.js

@@ +1 @@
+// New format RMS test
+
+

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

@@ +1 @@
+{
+    "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

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

@@ -1 @@
-const SIZE = 160;
-
-const sand = "beach_medit_dry";
-const grass1 = "grass_temperate_a";
-const grass2 = "grass_mediterranean_green_flowers";
-const forestFloor = "forrestfloor";
-const dirt1 = "grass_sand_75";
-const dirt2 = "grass_sand_50";
-const dirt3 = "dirt_brown_e";
-const cliffBase = "cliff base a";
-const cliffBeach = "beech_cliff_a_75";
-const cliff = "cliff_face3";
-
-const oTree = "flora_tree_oak";
-const oGrass = "props/flora/grass_soft_small.xml"
-const oMine = "geology_stone_light";
-
-// Initialize
-
-init(SIZE, grass1, 0);
-
-// Create classes
-
-clImpassable = createTileClass();
-clRock = createTileClass();
-
-// Paint elevation
-
-noise0 = new Noise2D(4 * SIZE/128.0);
-noise1 = new Noise2D(8 * SIZE/128.0);
-noise2 = new Noise2D(11 * SIZE/128.0);
-noise3 = new Noise2D(30 * SIZE/128.0);
-noise4 = new Noise2D(60 * SIZE/128.0);
-
-for(ix=0; ix<SIZE+1; ix++) {
-    for(iy=0; iy<SIZE+1; iy++) {
-        x = ix / (SIZE + 1.0);
-        y = iy / (SIZE + 1.0);
-        
-        // Calculate base noise
-        n = (noise0.eval(x, y) + 0.4 * noise1.eval(x, y)) / 1.4;
-        
-        T = .4; // Water cutoff
-        
-        if(n < T) {
-            // Tile is underwater - just scale the height down a bit
-            h = Math.max(-50 * (T-n)/T, -8);
-        }
-        else {
-            // Tile is above water - add some land noise depending on how far we are from the shoreline
-            u = 27*noise1.eval(x, y) + 14*noise2.eval(x,y) + 9 * noise3.eval(x,y) - 14;
-            h = 8*(n-T) + Math.max(0, lerp(0, u, Math.min(.1, n-T)*10));
-            h += 0.4*noise4.eval(x, y);
-        }
-        
-        setHeight(ix, iy, h);
-    }
-}
-
-// Paint terrains
-
-for(ix=0; ix<SIZE; ix++) {
-    for(iy=0; iy<SIZE; iy++) {
-        h00 = getHeight(ix, iy);
-        h01 = getHeight(ix, iy+1);
-        h10 = getHeight(ix+1, iy);
-        h11 = getHeight(ix+1, iy+1);
-        maxH = Math.max(h00, h01, h10, h11);
-        minH = Math.min(h00, h01, h10, h11);
-        if(maxH <= 0) {
-            setTexture(ix, iy, sand);
-            addToClass(ix, iy, clImpassable);
-        }
-        else if(maxH - minH > 3.2) {
-            setTexture(ix, iy, cliff);
-            addToClass(ix, iy, clImpassable);
-        }
-        else if(maxH - minH > 2.7) {
-            setTexture(ix, iy, cliffBase);
-            addToClass(ix, iy, clImpassable);
-        }
-        else if(minH <= 0) {
-            setTexture(ix, iy, sand);
-            addToClass(ix, iy, clImpassable);
-        }
-        else {
-            setTexture(ix, iy, grass1);
-        }
-    }
-}
-
-// Paint forest and dirt
-
-forestNoise1 = new Noise2D(20 * SIZE/128.0);
-forestNoise2 = new Noise2D(40 * SIZE/128.0);
-dirtNoise = new Noise2D(80 * SIZE/128.0);
-
-for(ix=0; ix<SIZE; ix++) {
-    for(iy=0; iy<SIZE; iy++) {
-        x = ix / (SIZE + 1.0);
-        y = iy / (SIZE + 1.0);
-        h00 = getHeight(ix, iy);
-        h01 = getHeight(ix, iy+1);
-        h10 = getHeight(ix+1, iy);
-        h11 = getHeight(ix+1, iy+1);
-        maxH = Math.max(h00, h01, h10, h11);
-        minH = Math.min(h00, h01, h10, h11);
-        if(maxH - minH < 1.7 && minH > 0) {
-            fn = (forestNoise1.eval(x,y) + .5*forestNoise1.eval(x,y)) / 1.5;
-            
-            if(minH > .5 && fn < .38 && dirtNoise.eval(x,y) > .55) {
-                if(dirtNoise.eval(x,y) > .72) {
-                    setTexture(ix, iy, dirt2);
-                }
-                else {
-                    setTexture(ix, iy, dirt1);
-                }
-            }
-            
-            if(fn > .6 && randFloat() < (.3 + .7 * Math.min(fn-.6, .1) / .1) ) {
-                placeObject(oTree, 0, ix+.4+.2*randFloat(), iy+.4+.2*randFloat(), randFloat()*2*Math.PI);
-                addToClass(ix, iy, clImpassable);
-                if(randFloat() < .7) {
-                    setTexture(ix, iy, forestFloor);
-                }
-            }
-        }
-    }
-}
-
-println("Creating mines...");
-group = new SimpleGroup([new SimpleObject(oMine, 3,4, 0,2)], true, clRock);
-createObjectGroups(group, 0,
-    new AvoidTileClassConstraint(clImpassable, 2, clRock, 13),
-    12, 100
-);
-

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

@@ -1 @@
-//TODO: Move to some library file?
-
-
-initFromScenario("mediterannean", LOAD_ALL);
-

binaries/data/mods/public/maps/test.html

@@ +1 @@
+
+<script type="text/javascript">
+    function log(text)
+    {
+        document.writeln(text+"<br />");
+    }
+    
+    // Check for typed arrays
+    if (typeof(Float32Array) == "undefined")
+    {
+        log("No typed array support, using Array...");
+        
+        // Standard arrays
+        function Float32Array(size)
+        {
+            var arr = new Array(size);
+            for (var i = 0; i < size; ++i)
+                arr[i] = 0;
+                
+            return arr;
+        }
+        function Uint16Array(size)
+        {
+            var arr = new Array(size);
+            for (var i = 0; i < size; ++i)
+                arr[i] = 0;
+                
+            return arr;
+        }
+        function Int16Array(size)
+        {
+            var arr = new Array(size);
+            for (var i = 0; i < size; ++i)
+                arr[i] = 0;
+                
+            return arr;
+        }
+        function Uint8Array(size)
+        {
+            var arr = new Array(size);
+            for (var i = 0; i < size; ++i)
+                arr[i] = 0;
+                
+            return arr;
+        }
+    }
+</script>
+
+<script src="mapgen/area.js"></script>
+<script src="mapgen/constraint.js"></script>
+<script src="mapgen/library.js"></script>
+<script src="mapgen/map.js"></script>
+<script src="mapgen/mapgen.js"></script>
+<script src="mapgen/MersenneTwister19937.js"></script>
+<script src="mapgen/noise.js"></script>
+<script src="mapgen/object.js"></script>
+<script src="mapgen/painter.js"></script>
+<script src="mapgen/placer.js"></script>
+<script src="mapgen/point.js"></script>
+<script src="mapgen/random.js"></script>
+<script src="mapgen/terrain.js"></script>
+<script src="mapgen/tileclass.js"></script>
+<script src="mapgen/vector.js"></script>
+
+<script type="text/javascript">
+    // Settings to pass into map generator
+    var settings = {
+        Size: 176,
+        Seed: 0,
+        BaseTerrain: ["medit_grass_field", "medit_grass_field_a", "medit_grass_flowers"],
+        BaseHeight: 0,
+        PlayerData: [ 
+            { Civ : "hele"},
+            { Civ : "hele"},
+            { Civ : "hele"},
+            { Civ : "hele"}
+        ]
+    };
+    
+    InitMapGen(settings);
+</script>
+
+<!--<script src="random/cantabrian_highlands.js"></script> -->
+<script src="random/latium.js"></script>
+
+<script type="text/javascript">
+    var output = SaveMap();
+    log("Done!!");
+    
+    // Print results
+    log("----------------------------------------------------------------------");
+    log("Number of entities="+output.entities.length);
+    for (var i = 0; i < output.entities.length; ++i)
+    {
+        var e = output.entities[i];
+        log("Entity "+ e.id +" = " + e.name + " ("+e.x + ", "+e.y+ ")  player="+e.player);
+    }
+    
+    log("----------------------------------------------------------------------");
+    log("Number of textures="+output.numTextures);
+    for (var i = 0; i < output.numTextures; ++i)
+    {
+        log("Texture "+ i +" = " + output.textureNames[i]);
+    }
+    
+</script>
+ No newline at end of file

source/graphics/Entity.h

@@ +1 @@
+/* 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

@@ +1 @@
+/* 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 "ps/CLogger.h"
+
+#define LOG_CATEGORY L"graphics"
+
+CMapGenerator::CMapGenerator() : m_ScriptInterface("Generator")
+{
+    // load mapgen libraries
+    LoadLibraries();
+}
+
+CScriptValRooted CMapGenerator::GenerateMap(const CStrW& scriptFile, const CScriptValRooted& settings)
+{
+    // 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
+    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;
+}
+ No newline at end of file

source/graphics/MapGenerator.h

@@ +1 @@
+/* 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 "MapIO.h"
+#include "lib/res/handle.h"
+#include "ps/CStr.h"
+#include "ps/FileIo.h"
+#include "scriptinterface/ScriptInterface.h"
+
+
+class CScriptValRooted;
+class ScriptInterface;
+
+
+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;
+
+};
+
+#endif
+ No newline at end of file

source/graphics/MapReader.cpp

@@ -21 +21 @@
 
 #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"
@@ -125 +127 @@
     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()
 {
@@ -1340 +1399 @@
 
     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 = 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 '" L#prop L"' property");\
+
+    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 '" L#prop L"' property");\
+
+    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 '" L#prop L"' property");\
+
+    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

@@ -82 +82 @@
     // 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
@@ -95 +114 @@
     // 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 @@
     }
     else if (mapType == "random")
     {
-        // TODO: Coming in another patch
+        // Load random map attributes
+        std::wstring scriptFile;
+        CScriptValRooted settings;
+
+        m_Simulation2->GetScriptInterface().GetProperty(attribs.get(), "script", scriptFile);
+        m_Simulation2->GetScriptInterface().GetProperty(attribs.get(), "settings", settings);
+
+        m_World->RegisterInit(scriptFile, settings, m_PlayerID);
     }
 
 

source/ps/World.cpp

@@ -94 +94 @@
     }
 }
 
+void CWorld::RegisterInit(const CStrW& scriptFile, const CScriptValRooted& settings, int playerID)
+{
+    // Load the map, if one was specified
+    if (scriptFile.length())
+    {
+        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

@@ -25 +25 @@
 #define INCLUDED_WORLD
 
 #include "ps/Errors.h"
+#include "scriptinterface/ScriptInterface.h"
 
 #ifndef ERROR_GROUP_GAME_DEFINED
 #define ERROR_GROUP_GAME_DEFINED
@@ -74 +75 @@
     */
     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

@@ -21 +21 @@
 
 #include "ps/utf16string.h"
 #include "ps/CLogger.h"
+#include "graphics/Color.h"
+#include "graphics/Entity.h"
 
 #include "js/jsapi.h"
 
@@ -79 +81 @@
     return true;
 }
 
+template<> bool ScriptInterface::FromJSVal<u16>(JSContext* cx, jsval v, u16& out)
+{
+    uint16 ret;
+    //WARN_IF_NOT(JSVAL_IS_INT(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)
 {
@@ -257 +269 @@
 {
     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)
+{
+    ScriptInterface::LocalRootScope scope(cx);
+    if (!scope.OK())
+        return false;
+
+    if (!JSVAL_IS_OBJECT(v))
+        return false; // TODO: report type error
+    JSObject* obj = JSVAL_TO_OBJECT(v);
+
+    jsval name, id, player, x, z, orient, actor;
+
+    if(!JS_GetProperty(cx, obj, "isActor", &actor)) return false;
+    if (!FromJSVal(cx, actor, out.isActor)) return false;
+
+    if (!out.isActor)
+    {
+        if(!JS_GetProperty(cx, obj, "player", &player)) return false;
+        if (!FromJSVal(cx, player, out.playerID)) return false;
+    }
+    
+    if (!JS_GetProperty(cx, obj, "name", &name)) return false; // TODO: report type errors
+    if (!JS_GetProperty(cx, obj, "id", &id)) return false;
+    if (!JS_GetProperty(cx, obj, "x", &x)) return false;
+    if (!JS_GetProperty(cx, obj, "y", &z)) return false;
+    if (!JS_GetProperty(cx, obj, "orientation", &orient)) return false;
+    // TODO: this probably has GC bugs if a getter returns an unrooted value
+
+    if (!FromJSVal(cx, name, out.templateName)) return false;
+    if (!FromJSVal(cx, id, out.entityID)) return false;
+    if (!FromJSVal(cx, x, out.positionX)) return false;
+    if (!FromJSVal(cx, z, out.positionZ)) return false;
+    if (!FromJSVal(cx, orient, out.orientationY)) return false;
+
+    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)
+{
+    ScriptInterface::LocalRootScope scope(cx);
+    if (!scope.OK())
+        return false;
+
+    if (!JSVAL_IS_OBJECT(v))
+        return false; // TODO: report type error
+    JSObject* obj = JSVAL_TO_OBJECT(v);
+
+    jsval r, g, b;
+    if (!JS_GetProperty(cx, obj, "r", &r)) return false; // TODO: report type errors
+    if (!JS_GetProperty(cx, obj, "g", &g)) return false;
+    if (!JS_GetProperty(cx, obj, "b", &b)) return false;
+    // TODO: this probably has GC bugs if a getter returns an unrooted value
+
+    if (!FromJSVal(cx, r, out.X)) return false;
+    if (!FromJSVal(cx, g, out.Y)) return false;
+    if (!FromJSVal(cx, b, out.Z)) return false;
+
+    return true;
+}
+ No newline at end of file

source/scriptinterface/ScriptInterface.cpp

@@ -272 +272 @@
         JS_SetOptions(m_cx, JSOPTION_STRICT // "warn on dubious practice"
                 | JSOPTION_XML // "ECMAScript for XML support: parse <!-- --> as a token"
                 | JSOPTION_VAROBJFIX // "recommended" (fixes variable scoping)
-//              | JSOPTION_JIT
+                | JSOPTION_JIT
         );
 
         JS_SetVersion(m_cx, JSVERSION_LATEST);