Ticket #2944: gen_wall_builder2015-8-3.patch

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

@@ -21 +21 @@
 // Heightmap functionality
 //////////
 
-// Some general heightmap settings
-const MIN_HEIGHT = - SEA_LEVEL; // 20, should be set in the libs!
-const MAX_HEIGHT = 0xFFFF/HEIGHT_UNITS_PER_METRE - SEA_LEVEL; // A bit smaler than 90, should be set in the libs!
-
 // Add random heightmap generation functionality
 function getRandomReliefmap(minHeight, maxHeight)
 {

binaries/data/mods/public/maps/random/rmgen/library.js

@@ -6 +6 @@
 const PI = Math.PI;
 const TWO_PI = 2 * Math.PI;
 const TERRAIN_SEPARATOR = "|";
-const SEA_LEVEL = 20.0;
+const SEA_LEVEL = 160.0;
 const CELL_SIZE = 4;
 const HEIGHT_UNITS_PER_METRE = 92;
 const MIN_MAP_SIZE = 128;
 const MAX_MAP_SIZE = 512;
 const FALLBACK_CIV = "athen";
+// Constants needed for heightmap_manipulation.js
+const MAX_HEIGHT_RANGE = 0xFFFF / HEIGHT_UNITS_PER_METRE // Engine limit, Roughly 700 meters
+const MIN_HEIGHT = - SEA_LEVEL;
+const MAX_HEIGHT = MAX_HEIGHT_RANGE - SEA_LEVEL;
+// Entity template structure keys that might change, for easier mod support
+const STARTING_ENTITY_KEY = "StartEntities";
+const START_ENTITY_TEMPLATE_PATH_KEY = "Template"
+const BUILDER_TEMPLATEPATH_KEYS = ["Builder", "Entities", "_string"];
+const PRODUCTION_TEMPLATEPATH_KEYS = ["ProductionQueue", "Entities", "_string"];
+const CIV_PLACEHOLDER_STRING = "{civ}";
 
 /////////////////////////////////////////////////////////////////////////////////////////////
 //  Utility functions
@@ -394 +404 @@
     return g_MapSettings.PlayerData.length - 1;
 }
 
+// Takes nothing, returns an array of strings representing all available civilizations
+function getCivList()
+{
+    var raw_civData = RMS.GetCivData();
+    var civList = [];
+    for (var i = 0; i < raw_civData.length; ++i)
+        civList.push(JSON.parse(raw_civData[i]).Code);
+    
+    return civList;
+}
+
+// Takes nothing, returns an associative array with civ strings as keys containing all unpacked civ data (Templates need to be unpacked with RMS.GetTemplate() if needed)
+function getFullCivData()
+{
+    var rawCivData = RMS.GetCivData();
+    var unpackedCivData = {};
+    for (var i = 0; i < rawCivData.length; i++)
+    {
+        var singleCivData = JSON.parse(rawCivData[i]);
+        unpackedCivData[singleCivData.Code] = singleCivData;
+    }
+    
+    return unpackedCivData;
+}
+
+// Takes a player number (0-7, so Gaia excluded). Returns this players civ string
+// ToDo: If the player number is to high an error will occur (and the fallback won't be reached)!
 function getCivCode(player)
 {
     if (g_MapSettings.PlayerData[player+1].Civ)
         return g_MapSettings.PlayerData[player+1].Civ;
 
-    warn("undefined civ specified for player " + (player + 1) + ", falling back to '" + FALLBACK_CIV + "'");
+    warn("Undefined civ specified for player " + (player + 1) + ", falling back to '" + FALLBACK_CIV + "'");
     return FALLBACK_CIV;
 }
 
+// Takes an entity path and a key list to get the templates value
+function getTemplateValue(entPath, key_list)
+{
+    var subdata = RMS.GetTemplate(entPath);
+    for (var i = 0; i < key_list.length; i++)
+    {
+        if (key_list[i] in subdata)
+        {
+            subdata = subdata[key_list[i]];
+        }
+        else
+        {
+            return false;
+        }
+    }
+    return subdata;
+}
+
+// Returns a list of all templates paths available to the given civ
+function getTempatePathList(civ)
+{
+    var templatePaths = getFullCivData();
+    if (civ in templatePaths)
+    {
+        templatePaths = templatePaths[civ];
+    }
+    else
+    {
+        var keys = [];
+        for (var key in templatePaths)
+            keys.push(key);
+        warn("getTempatePathList: Unknown civ: " + civ + " not in " + uneval(keys));
+        return false;
+    }
+    if (STARTING_ENTITY_KEY in templatePaths)
+    {
+        templatePaths = templatePaths[STARTING_ENTITY_KEY];
+    }
+    else
+    {
+        var keys = [];
+        for (var key in templatePaths)
+            keys.push(key);
+        warn("getTempatePathList: Civ has no starting entities as defined in STARTING_ENTITY_KEY (" + STARTING_ENTITY_KEY + "): " + uneval(keys));
+        return false;
+    }
+    for (var i = 0; i < templatePaths.length; i++)
+    {
+        if (START_ENTITY_TEMPLATE_PATH_KEY in templatePaths[i])
+        {
+            templatePaths[i] = templatePaths[i][START_ENTITY_TEMPLATE_PATH_KEY];
+        }
+        else
+        {
+            var keys = [];
+            for (var key in templatePaths[i])
+                keys.push(key);
+            warn("getTempatePathList: Starting entity list item has no template as defined in START_ENTITY_TEMPLATE_PATH_KEY (" + START_ENTITY_TEMPLATE_PATH_KEY + "): " + uneval(keys));
+            return false;
+        }
+    }
+    var foundNew = 1;
+    while (foundNew > 0)
+    {
+        foundNew = 0;
+        var methods = [BUILDER_TEMPLATEPATH_KEYS, PRODUCTION_TEMPLATEPATH_KEYS];
+        for (var m = 0; m < methods.length; m++)
+        {
+            for (var t = 0; t < templatePaths.length; t++)
+            {
+                var pathsToCheck = getTemplateValue(templatePaths[t], methods[m]);
+                if (typeof(pathsToCheck) === typeof(""))
+                {
+                    pathsToCheck = pathsToCheck.split(/\s+/);
+                    for (var c = 0; c < pathsToCheck.length; c++)
+                    {
+                        var actualPath = pathsToCheck[c].replace(CIV_PLACEHOLDER_STRING, civ);
+                        if (templatePaths.indexOf(actualPath) == -1 && RMS.TemplateExists(actualPath))
+                        {
+                            templatePaths.push(actualPath);
+                            foundNew++;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return templatePaths;
+}
+
 function areAllies(player1, player2)
 {
     if ((g_MapSettings.PlayerData[player1+1].Team === undefined) || (g_MapSettings.PlayerData[player2+1].Team === undefined) || (g_MapSettings.PlayerData[player2+1].Team == -1) || (g_MapSettings.PlayerData[player1+1].Team == -1))

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

@@ -1 @@
-var TILE_CENTERED_HEIGHT_MAP = false;
+var TILE_CENTERED_HEIGHT_MAP = false; // Only touch this if you REALLY KNOW what you are doing!
 var WATER_LEVEL_CHANGED = false;
 
 var g_Map;

binaries/data/mods/public/maps/random/rmgen/misc.js

@@ -157 +157 @@
     }
 }
 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // placeCivDefaultEntities
 //
 //  Creates the default starting player entities depending on the players civ
 //  fx&fy: position of player base
 //  playerid: id of player
 //  angle: angle of main base building, optional, default is BUILDING_ANGlE
-//  kwargs: Takes some optional keyword arguments to tweek things
-//      'iberWall': may be false, 'walls' (default) or 'towers'. Determines the defensive structures Iberians get as civ bonus
+//  kwargs: Optional. Takes an associative array with keyword arguments to tweak things:
+//      Known keys: 'iberWall': may be false, 'walls' (default) or 'towers'. Determines the defensive structures Iberians get as civ bonus
 //
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 function placeCivDefaultEntities(fx, fz, playerid, angle, kwargs)
 {
     // Unpack kwargs

binaries/data/mods/public/maps/random/rmgen/wall_builder.js

@@ -107 +107 @@
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 var wallStyles = {};
 
-// Generic civ dependent wall style definition. "rome_siege" needs some tweek...
-var wallScaleByType = {"athen" : 1.5, "brit" : 1.5, "cart" : 1.8, "gaul" : 1.5, "iber" : 1.5, "mace" : 1.5, "maur": 1.5, "pers" : 1.5, "ptol" : 1.5, "rome" : 1.5, "sele" : 1.5, "spart" : 1.5, "rome_siege" : 1.5};
+// Get wall element width by template and angle
+function getTemplateWidthByAngle(templatePath, angle)
+{
+    var template = RMS.GetTemplate(templatePath);
+    var width = undefined;
+    if (template.hasOwnProperty("Footprint"))
+    {
+        if (template.Footprint.hasOwnProperty("Square"))
+        {
+            if (template.Footprint.Square.hasOwnProperty("@width"))
+            {
+                if (template.Footprint.Square.hasOwnProperty("@depth"))
+                {
+                    width = max(parseFloat(template.Footprint.Square["@width"]) * abs(cos(angle)), parseFloat(template.Footprint.Square["@depth"]) * abs(sin(angle))) / CELL_SIZE;
+                }
+                else
+                {
+                    warn("wall_builder.js: getTemplateWidthByAngle(): Template " + templatePath + " has a square Footprint but no property '@depth'");
+                }
+            }
+            else
+            {
+                warn("wall_builder.js: getTemplateWidthByAngle(): Template " + templatePath + " has a square Footprint but no property '@width'");
+            }
+        }
+        else if (template.Footprint.hasOwnProperty("Circle"))
+        {
+            if (template.Footprint.Circle.hasOwnProperty("@radius"))
+            {
+                width = parseFloat(template.Footprint.Circle["@radius"]) / CELL_SIZE;
+            }
+            else
+            {
+                warn("wall_builder.js: getTemplateWidthByAngle(): Template " + templatePath + " has a circle Footprint but no property '@radius'");
+            }
+        }
+        else
+        {
+            warn("wall_builder.js: getTemplateWidthByAngle(): Template " + templatePath + " has a Footprint that is neither 'Square' nor 'Circle'");
+        }
+    }
+    else
+    {
+        warn("wall_builder.js: getTemplateWidthByAngle(): Template " + templatePath + " has no property'Footprint'");
+    }
+    
+    return width;
+}
+
+// Add new WallElement by it's properties
+function addNewWallElement(style, name, angle)
+{
+    var templatePath = "structures/" + style + "_" + name
+    wallStyles[style][name] = new WallElement(name, templatePath, angle, getTemplateWidthByAngle(templatePath, angle));
+}
+
+// Find all wall sets by civ to be then put into wallStyles
+var entitiesByCiv = {};
+var civList = getCivList();
+for (var i = 0; i < civList.length; i++)
+{
+    var civ = civList[i];
+    var templatePathList = getTempatePathList(civ);
+    entitiesByCiv[civ] = templatePathList;
+}
+
+// Generic civ dependent wall style definition. Some, e.g. "rome_siege" needs tweaking...
+var wallScaleByType = {}; // To be removed TODO
+var civData = getFullCivData();
+for (var i = 0; i < civList.length; i++)
+{
+    var civ = civList[i];
+    var wallSets = civData[civ].WallSets;
+    if (wallSets.hasOwnProperty("Stone"))
+        wallScaleByType[civ] = wallSets.Stone.Scale; // Wallset Stone still hardcoded
+}
+// Non-civ but civ specific wall styles
+wallScaleByType.rome_siege = 1.5;
 for (var style in wallScaleByType)
 {
     var civ = style;
@@ -116 +192 @@
         civ = "rome";
     wallStyles[style] = {};
     // Default wall elements
-    wallStyles[style]["tower"] = new WallElement("tower", "structures/" + style + "_wall_tower", PI, wallScaleByType[style]);
+    var templatePath = "structures/" + style + "_wall_tower";
+    var angle = PI;
+    var width = getTemplateWidthByAngle(templatePath, angle); // DEBUG
+    log("getTemplateWidthByAngle(" + templatePath + ") =  " + width + ", used to be width = " + wallScaleByType[style]); // DEBUG
+    // wallStyles[style]["tower"] = new WallElement("tower", templatePath, angle, width);//wallScaleByType[style]);
+    addNewWallElement(style, "wall_tower", PI);
+    wallStyles[style]["tower"] = wallStyles[style]["wall_tower"]; // Shortcut
+    
     wallStyles[style]["endLeft"] = new WallElement("endLeft", "structures/" + style + "_wall_tower", PI, wallScaleByType[style]); // Same as tower. To be compatible with palisades...
     wallStyles[style]["endRight"] = new WallElement("endRight", "structures/" + style + "_wall_tower", PI, wallScaleByType[style]); // Same as tower. To be compatible with palisades...
     wallStyles[style]["cornerIn"] = new WallElement("cornerIn", "structures/" + style + "_wall_tower", 5*PI/4, 0, 0.35*wallScaleByType[style], PI/2); // 2^0.5 / 4 ~= 0.35 ~= 1/3
     wallStyles[style]["cornerOut"] = new WallElement("cornerOut", "structures/" + style + "_wall_tower", 3*PI/4, 0.71*wallScaleByType[style], 0, -PI/2); // // 2^0.5 / 2 ~= 0.71 ~= 2/3
+    
+    var templatePath = "structures/" + style + "_wall_short"; // DEBUG
+    var angle = 0*PI; // DEBUG
+    var width = getTemplateWidthByAngle(templatePath, angle); // DEBUG
+    log("getTemplateWidthByAngle(" + templatePath + ") =  " + width + ", used to be width = " + 2*wallScaleByType[style]); // DEBUG
     wallStyles[style]["wallShort"] = new WallElement("wallShort", "structures/" + style + "_wall_short", 0*PI, 2*wallScaleByType[style]);
+    
+    var templatePath = "structures/" + style + "_wall_medium"; // DEBUG
+    var angle = 0*PI; // DEBUG
+    var width = getTemplateWidthByAngle(templatePath, angle); // DEBUG
+    log("getTemplateWidthByAngle(" + templatePath + ") =  " + width + ", used to be width = " + 4*wallScaleByType[style]); // DEBUG
     wallStyles[style]["wall"] = new WallElement("wall", "structures/" + style + "_wall_medium", 0*PI, 4*wallScaleByType[style]);
+    
     wallStyles[style]["wallMedium"] = new WallElement("wall", "structures/" + style + "_wall_medium", 0*PI, 4*wallScaleByType[style]);
+    
+    var templatePath = "structures/" + style + "_wall_long"; // DEBUG
+    var angle = 0*PI; // DEBUG
+    var width = getTemplateWidthByAngle(templatePath, angle); // DEBUG
+    log("getTemplateWidthByAngle(" + templatePath + ") =  " + width + ", used to be width = " + 6*wallScaleByType[style]); // DEBUG
     wallStyles[style]["wallLong"] = new WallElement("wallLong", "structures/" + style + "_wall_long", 0*PI, 6*wallScaleByType[style]);
+    
     // Gate and entrance wall elements
     var gateWidth = 6*wallScaleByType[style];
+    
+    var templatePath = "structures/" + style + "_wall_gate"; // DEBUG
+    var angle = PI; // DEBUG
+    var width = getTemplateWidthByAngle(templatePath, angle); // DEBUG
+    log("getTemplateWidthByAngle(" + templatePath + ") =  " + width + ", used to be width = " + 6*wallScaleByType[style]); // DEBUG
     wallStyles[style]["gate"] = new WallElement("gate", "structures/" + style + "_wall_gate", PI, gateWidth);
+    
     wallStyles[style]["entry"] = new WallElement("entry", undefined, 0*PI, gateWidth);
     wallStyles[style]["entryTower"] = new WallElement("entryTower", "structures/" + civ + "_defense_tower", PI, gateWidth, -4*wallScaleByType[style]);
     wallStyles[style]["entryFort"] = new WallElement("entryFort", "structures/" + civ + "_fortress", 0*PI, 8*wallScaleByType[style], 6*wallScaleByType[style]);
@@ -161 +267 @@
 wallStyles["pers"]["wallFort"] = new WallElement("wallFort", "structures/pers_fortress", PI, 5.6/*5.5*/, 1.9/*1.7*/);
 wallStyles["ptol"]["wallFort"] = new WallElement("wallFort", "structures/ptol_fortress", 2*PI/2 /* PI/2 */, 5.1 /* 5.6 */, 1.9 /* 1.9 */);
 wallStyles["rome"]["wallFort"] = new WallElement("wallFort", "structures/rome_fortress", PI, 6.3, 2.1);
-wallStyles["sele"]["wallFort"] = new WallElement("wallFort", "structures/sele_fortress", 2*PI/2 /* PI/2 */, 5.1 /* 5.6 */, 1.9 /* 1.9 */);
 wallStyles["spart"]["wallFort"] = new WallElement("wallFort", "structures/spart_fortress", 2*PI/2 /* PI/2 */, 5.1 /* 5.6 */, 1.9 /* 1.9 */);
 // Adjust "rome_siege" style
 wallStyles["rome_siege"]["wallFort"] = new WallElement("wallFort", "structures/rome_army_camp", PI, 7.2, 2);
@@ -339 +444 @@
     {
         var element = wallStyles[style][wall[i]];
         if (element === undefined && i == 0)
-            warn("No valid wall element: " + wall[i]);
+            warn("No valid wall element: style = " + style + ", wall[" + i + "] = " + wall[i] + ", wallStyles[" + style + "][wall[" + i + "]] = " + wallStyles[style][wall[i]] + ", element = " + element + ", wall = " + wall);
         // Indentation
         var placeX = wallX - element.indent * cos(orientation);
         var placeY = wallY - element.indent * sin(orientation);
@@ -351 +456 @@
             orientation += element.bending;
             var nextElement = wallStyles[style][wall[i+1]];
             if (nextElement === undefined)
-                warn("No valid wall element: " + wall[i+1]);
+                warn("No valid wall element: style = " + style + ", wall[" + (i+1) + "] = " + wall[i+1] + ", wallStyles[" + style + "][wall[" + (i+1) + "]] = " + wallStyles[style][wall[i+1]] + ", nextElement = " + uneval(nextElement) + ", wall = " + wall);
             var distance = (element.width + nextElement.width)/2;
             // Corrections for elements with indent AND bending
             var indent = element.indent;
@@ -624 +729 @@
 //  maxBendOff    Optional. How irregular the circle should be. 0 means regular circle, PI/2 means very irregular. Default is 0 (regular circle)
 //
 //  NOTE: Don't use wall elements with bending like corners!
-//  TODO: Perhaps add eccentricity and maxBendOff functionality (untill now an unused argument)
+//  TODO: Perhaps add eccentricity
+//  TODO: Check if maxBendOff parameter works in all cases
 //  TODO: Perhaps add functionality for spirals
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 function placeCircularWall(centerX, centerY, radius, wallPart, style, playerId, orientation, maxAngle, endWithFirst, maxBendOff)
@@ -652 +758 @@
     
     // Check arguments
     if (maxBendOff > PI/2 || maxBendOff < 0)
-        warn("placeCircularWall maxBendOff sould satisfy 0 < maxBendOff < PI/2 (~1.5) but it is: " + maxBendOff);
+        warn("placeCircularWall maxBendOff should satisfy 0 < maxBendOff < PI/2 (~1.5) but it is: " + maxBendOff);
     for (var elementIndex = 0; elementIndex < wallPart.length; elementIndex++)
     {
         var bending = wallStyles[style][wallPart[elementIndex]].bending;

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

@@ -131 +131 @@
 // Setup paths
 var pathSucsessRadius = baseRadius/2;
 var pathAngleOff = PI/2;
-var pathWidth = 10; // This is not really the path's thickness in tiles but the number of tiles in the clumbs of the path
+var pathWidth = 10; // This is not really the path's thickness in tiles but the number of tiles in the clumps of the path
 
 // Setup additional resources
 var resourceRadius = 2*mapRadius/3; // 3*mapRadius/8;
@@ -232 +232 @@
 //
 ////////////////
 
-// Some heightmap constants
-const MIN_HEIGHT = - SEA_LEVEL; // -20
-const MAX_HEIGHT = 0xFFFF/HEIGHT_UNITS_PER_METRE - SEA_LEVEL; // A bit smaller than 90
-
 // Get the diferrence between minimum and maxumum height
 function getMinAndMaxHeight(reliefmap)
 {

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

@@ -62 +62 @@
 var actualX = distToMapBorder;
 var actualY = distToMapBorder;
 // Wall styles are chosen by strings so the civ strings got by getCivCode() can be used
-// Other styles may be present as well but besides the civ styles only 'palisades' includes all wall element types (yet)
-const wallStyleList = ["athen", "brit", "cart", "gaul", "iber", "mace", "maur", "pers", "ptol", "rome", "sele", "spart", "rome_siege", "palisades"];
+var wallStyleList = getCivList();
+// Other styles may be available as well...
+wallStyleList.push("rome_siege");
+wallStyleList.push("palisades");
+// Check if all wall styles are present and remove unknown ones
+for (var i = 0; i < wallStyleList.length; i++)
+    if (!wallStyles.hasOwnProperty(wallStyleList[i]))
+        wallStyleList.splice(i, 1);
 
 
 ////////////////////////////////////////
@@ -74 +80 @@
 {
     var startX = actualX + styleIndex * buildableMapSize/wallStyleList.length; // X coordinate of the first wall element
     var startY = actualY; // Y coordinate of the first wall element
-    var style = wallStyleList[styleIndex]; // // The wall's style like 'cart', 'iber', 'pers', 'rome', 'romeSiege' or 'palisades'
-    var orientation = styleIndex * PI/64; // Orientation of the first wall element. 0 means 'outside' or 'front' is right (positive X, like object placement)
+    var style = wallStyleList[styleIndex]; // The wall's style like 'cart', 'iber', 'pers', 'rome', 'romeSiege' or 'palisades'
+    var orientation = PI/16 * sin(styleIndex * PI/4); // Orientation of the first wall element. 0 means 'outside' or 'front' is right (positive X, like object placement in Atlas)
     // That means the wall will be build towards top (positive Y) if no corners are used
     var playerId = 0; // Owner of the wall (like in placeObject). 0 is Gaia, 1 is Player 1 (default color blue), ...
     placeWall(startX, startY, wall, style, playerId, orientation); // Actually placing the wall
@@ -155 +161 @@
 {
     for (var wallIndex = 0; wallIndex < numWallsPerStyle; wallIndex++)
     {
-        var startX = actualX + (styleIndex * numWallsPerStyle + wallIndex) * distToOtherWalls; // X coordinate the wall will start from
+        var startX = actualX + (styleIndex * numWallsPerStyle + wallIndex) * buildableMapSize/wallStyleList.length/numWallsPerStyle; // X coordinate the wall will start from
         var startY = actualY; // Y coordinate the wall will start from
         var endX = startX; // X coordinate the wall will end
         var endY = actualY + (wallIndex + 1) * maxWallLength/numWallsPerStyle; // Y coordinate the wall will end
@@ -167 +173 @@
         // placeObject(endX, endY, 'other/obelisk', 0, 0*PI); // Place visual marker to see where exsactly the wall ends
     }
 }
-actualX = distToMapBorder; // Reset actualX
-actualY += maxWallLength + distToOtherWalls; // Increase actualY for next wall placement method
 
 
 // Export map data

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

@@ -2 +2 @@
     "settings" : {
         "Name" : "Wall Demo",
         "Script" : "wall_demo.js",
-        "Description" : "A demonstration of wall placement methods/code in random maps. Very large map size is recommended.",
+        "Description" : "A demonstration of wall placement methods/code in random maps. Giant map size is recommended!",
         "BaseTerrain" : ["grass1"],
         "BaseHeight" : 0,
         "Keywords": ["demo"],

binaries/data/mods/public/simulation/data/civs/athen.json

@@ -109 +109 @@
             "Special":"Train heroes and research technology pertaining to heroes."
         }
     ],
+    "WallSets":
+    {
+        "Palisades":
+        {
+            "Template": "other/wallset_palisade",
+            "Scale": 0.55
+        },
+        "Stone":
+        {
+            "Template": "structures/athen_wallset_stone",
+            "Scale": 1.5
+        }
+    },
     "StartEntities":
     [
         {

binaries/data/mods/public/simulation/data/civs/brit.json

@@ -87 +87 @@
             "Special": "" 
         } 
     ],
+    "WallSets":
+    {
+        "Palisades":
+        {
+            "Template": "other/wallset_palisade",
+            "Scale": 0.55
+        },
+        "Stone":
+        {
+            "Template": "structures/athen_wallset_stone",
+            "Scale": 1.5
+        }
+    },
     "StartEntities":
     [
         {

binaries/data/mods/public/simulation/data/civs/cart.json

@@ -112 +112 @@
             "Special":"Hire Iberian mercenaries."
         }       
     ],
+    "WallSets":
+    {
+        "Palisades":
+        {
+            "Template": "other/wallset_palisade",
+            "Scale": 0.55
+        },
+        "Stone":
+        {
+            "Template": "structures/athen_wallset_stone",
+            "Scale": 1.8
+        }
+    },
     "StartEntities":
     [
         {

binaries/data/mods/public/simulation/data/civs/gaul.json

@@ -87 +87 @@
             "Special": "" 
         } 
     ],
+    "WallSets":
+    {
+        "Palisades":
+        {
+            "Template": "other/wallset_palisade",
+            "Scale": 0.55
+        },
+        "Stone":
+        {
+            "Template": "structures/athen_wallset_stone",
+            "Scale": 1.5
+        }
+    },
     "StartEntities":
     [
         {

binaries/data/mods/public/simulation/data/civs/iber.json

@@ -85 +85 @@
             "Special": "Defensive Aura - Gives all Iberian units and buildings within vision range of the monument a 10-15% attack boost. Build Limit: Only 5 may be built per map."
         } 
     ],
+    "WallSets":
+    {
+        "Palisades":
+        {
+            "Template": "other/wallset_palisade",
+            "Scale": 0.55
+        },
+        "Stone":
+        {
+            "Template": "structures/athen_wallset_stone",
+            "Scale": 1.5
+        }
+    },
     "StartEntities":
     [
         {

binaries/data/mods/public/simulation/data/civs/mace.json

@@ -114 +114 @@
             "Special":"Constructs and upgrades all Macedonian siege engines."
         }
     ],
+    "WallSets":
+    {
+        "Palisades":
+        {
+            "Template": "other/wallset_palisade",
+            "Scale": 0.55
+        },
+        "Stone":
+        {
+            "Template": "structures/athen_wallset_stone",
+            "Scale": 1.5
+        }
+    },
     "StartEntities":
     [
         {

binaries/data/mods/public/simulation/data/civs/maur.json

@@ -94 +94 @@
             "Special":"Contentment: +10% Health and +10% resource gathering rates for all citizens and allied citizens within its range. Can be built anywhere except in enemy territory. Max Built: 10."
         }
     ],
+    "WallSets":
+    {
+        "Palisades":
+        {
+            "Template": "other/wallset_palisade",
+            "Scale": 0.55
+        },
+        "Stone":
+        {
+            "Template": "structures/athen_wallset_stone",
+            "Scale": 1.5
+        }
+    },
     "StartEntities":
     [
         {

binaries/data/mods/public/simulation/data/civs/pers.json

@@ -104 +104 @@
             "Special": "Train heroes and Persian Immortals. Gives a slow trickle of all resources as 'Satrapy Tribute.'" 
         }
     ],
+    "WallSets":
+    {
+        "Palisades":
+        {
+            "Template": "other/wallset_palisade",
+            "Scale": 0.55
+        },
+        "Stone":
+        {
+            "Template": "structures/athen_wallset_stone",
+            "Scale": 1.5
+        }
+    },
     "StartEntities":
     [
         {

binaries/data/mods/public/simulation/data/civs/ptol.json

@@ -113 +113 @@
             "Special":"When built along the shoreline, removes shroud of darkness over all the water, revealing all the coast lines on the map. Limit: 1."
         }
     ],
+    "WallSets":
+    {
+        "Palisades":
+        {
+            "Template": "other/wallset_palisade",
+            "Scale": 0.55
+        },
+        "Stone":
+        {
+            "Template": "structures/athen_wallset_stone",
+            "Scale": 1.5
+        }
+    },
     "StartEntities":
     [
         {

binaries/data/mods/public/simulation/data/civs/rome.json

@@ -89 +89 @@
             "Special": "Can be built in neutral and enemy territory to strangle enemy towns." 
         } 
     ],
+    "WallSets":
+    {
+        "Palisades":
+        {
+            "Template": "other/wallset_palisade",
+            "Scale": 0.55
+        },
+        "Stone":
+        {
+            "Template": "structures/athen_wallset_stone",
+            "Scale": 1.5
+        },
+        "Siege":
+        {
+            "Template": "structures/rome_wallset_siege",
+            "Scale": 1.5
+        }
+    },
     "StartEntities":
     [
         {

binaries/data/mods/public/simulation/data/civs/sele.json

@@ -114 +114 @@
             "Special":"This is the Seleucid expansion building, similar to Civic Centers for other factions. It is weaker and carries a smaller territory influence, but is cheaper and built faster."
         }
     ],
+    "WallSets":
+    {
+        "Palisades":
+        {
+            "Template": "other/wallset_palisade",
+            "Scale": 0.55
+        }
+    },
     "StartEntities":
     [
         {

binaries/data/mods/public/simulation/data/civs/spart.json

@@ -105 +105 @@
             "Special":"Train heroes and Spartiates and research technologies related to them."
         }
     ],
+    "WallSets":
+    {
+        "Palisades":
+        {
+            "Template": "other/wallset_palisade",
+            "Scale": 0.55
+        },
+        "Stone":
+        {
+            "Template": "structures/athen_wallset_stone",
+            "Scale": 1.5
+        }
+    },
     "StartEntities":
     [
         {