Ticket #5090: meh.patch

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

@@ -244 +244 @@
  */
 const layoutKushCity = [
     {
         "templateName": "uncapturable|" + oHouse,
         "difficulty": "Very Easy",
-        "painters": new TileClassPainter(clHouse)
+        "painters": new TileClassPainter(clHouse),
+        "faceTowardsBorder": false
     },
     {
         "templateName": "uncapturable|" + oFortress,
         "difficulty": "Medium",
         "constraints": [avoidClasses(clFortress, 25), new NearTileClassConstraint(clPath, 8)],
-        "painters": new TileClassPainter(clFortress)
+        "painters": new TileClassPainter(clFortress),
+        "faceTowardsBorder": true
     },
     {
         "templateName": "uncapturable|" + oCivicCenter,
         "difficulty": "Easy",
         "constraints": [avoidClasses(clCivicCenter, 60), new NearTileClassConstraint(clPath, 8)],
-        "painters": new TileClassPainter(clCivicCenter)
+        "painters": new TileClassPainter(clCivicCenter),
+        "faceTowardsBorder": true
     },
     {
         "templateName": "uncapturable|" + oElephantStables,
         "difficulty": "Medium",
         "constraints": avoidClasses(clElephantStables, 10),
-        "painters": new TileClassPainter(clElephantStables)
+        "painters": new TileClassPainter(clElephantStables),
+        "faceTowardsBorder": true
     },
     {
         "templateName": "uncapturable|" + oStable,
         "difficulty": "Easy",
         "constraints": avoidClasses(clStable, 20),
-        "painters": new TileClassPainter(clStable)
+        "painters": new TileClassPainter(clStable),
+        "faceTowardsBorder": true
     },
     {
         "templateName": "uncapturable|" + oBarracks,
         "difficulty": "Easy",
         "constraints": avoidClasses(clBarracks, 12),
-        "painters": new TileClassPainter(clBarracks)
+        "painters": new TileClassPainter(clBarracks),
+        "faceTowardsBorder": true
     },
     {
         "templateName": "uncapturable|" + oTower,
         "difficulty": "Medium",
         "constraints": avoidClasses(clTower, 17),
-        "painters": new TileClassPainter(clTower)
+        "painters": new TileClassPainter(clTower),
+        "faceTowardsBorder": false
     },
     {
         "templateName": "uncapturable|" + oMarket,
         "difficulty": "Very Easy",
         "constraints": avoidClasses(clMarket, 15),
-        "painters": new TileClassPainter(clMarket)
+        "painters": new TileClassPainter(clMarket),
+        "faceTowardsBorder": true
     },
     {
         "templateName": "uncapturable|" + oBlacksmith,
         "difficulty": "Very Easy",
         "constraints": avoidClasses(clBlacksmith, 30),
-        "painters": new TileClassPainter(clBlacksmith)
+        "painters": new TileClassPainter(clBlacksmith),
+        "faceTowardsBorder": true
     },
     {
         "templateName": "uncapturable|" + oNubaVillage,
         "difficulty": "Easy",
         "constraints": avoidClasses(clNubaVillage, 30),
-        "painters": new TileClassPainter(clNubaVillage)
+        "painters": new TileClassPainter(clNubaVillage),
+        "faceTowardsBorder": true
     },
     {
         "templateName": "uncapturable|" + oBlemmyeCamp,
         "difficulty": "Easy",
         "constraints": avoidClasses(clBlemmyeCamp, 30),
-        "painters": new TileClassPainter(clBlemmyeCamp)
+        "painters": new TileClassPainter(clBlemmyeCamp),
+        "faceTowardsBorder": true
     }
 ].filter(building => getDifficulty() >= getDifficulties().find(difficulty => difficulty.Name == building.difficulty).Difficulty);
 
 g_WallStyles.napata = {
     "short": readyWallElement("uncapturable|" + oWallMedium),

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

@@ -5 +5 @@
 
 placePlayerBases({
     "PlayerPlacement": playerPlacementCircle(fractionToTiles(0.39))
 });
 
+createArea(
+    new DiskPlacer(g_Map.getSize() / 3, g_Map.getCenter()),
+    [
+        new TerrainPainter("blue"),
+        new CityPainter([{
+            "templateName": "uncapturable|structures/kush_elephant_stables",
+            "faceTowardsBorder": true
+        }], Math.PI / 2, 0)
+    ]);
+
 placePlayersNomad(g_Map.createTileClass());
 
 g_Map.ExportMap();

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

@@ -41 +41 @@
         }
     }
 
     return closestPoint;
 };
+
+/**
+ * Returns an area consisting of all points adjacent to this area.
+ */
+Area.prototype.getBorderArea = function(borderWidth)
+{
+    let tileclassArea = g_Map.createTileClass();
+
+    createArea(
+        new MapBoundsPlacer(),
+        new TileClassPainter(tileclassArea),
+        new StayAreasConstraint([this]));
+
+    return createArea(
+        new MapBoundsPlacer(),
+        undefined,
+        [
+            new AvoidAreasConstraint([this]),
+            new NearTileClassConstraint(tileclassArea, borderWidth),
+        ]);
+};

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

@@ -333 +333 @@
 function getDifficulty()
 {
     let level = g_MapSettings.TriggerDifficulty || 3;
     return getDifficulties().find(difficulty => difficulty.Difficulty == level).Difficulty;
 }
+
+function findPointInDirection(startPoint, endPoint, constraint, offset = 0)
+{
+    let stepVec = Vector2D.sub(endPoint, startPoint);
+    let distance = Math.ceil(stepVec.length());
+    stepVec.normalize();
+
+    for (let i = 0; i < distance; ++i)
+    {
+        let pos = Vector2D.add(startPoint, Vector2D.mult(stepVec, i));
+        let ipos = pos.clone().round();
+
+        if (!g_Map.inMapBounds(ipos))
+            return undefined;
+
+        if (constraint.allows(ipos))
+            return pos.add(stepVec.mult(offset));
+    }
+
+    return undefined;
+}

binaries/data/mods/public/maps/random/rmgen/painter/CityPainter.js

@@ -11 +11 @@
         return {
             "templateName": template.templateName,
             "maxCount": template.maxCount !== undefined ? template.maxCount : Infinity,
             "constraint": template.constraints && new AndConstraint(template.constraints),
             "painter": template.painters && new MultiPainter(template.painters),
+            "obstructionMaxLengthSquared": Math.square(1.5 * Math.max(obstructionSize.x, obstructionSize.y)),
+            "obstructionCenter": Vector2D.div(obstructionSize, 2),
             "obstructionCorners": [
-                new Vector2D(0, 0),
-                new Vector2D(obstructionSize.x, 0),
-                new Vector2D(0, obstructionSize.y),
-                obstructionSize
-            ]
+                new Vector2D(-obstructionSize.x, +obstructionSize.y).div(2),
+                new Vector2D(-obstructionSize.x, -obstructionSize.y).div(2),
+                new Vector2D(+obstructionSize.x, +obstructionSize.y).div(2),
+                new Vector2D(+obstructionSize.x, -obstructionSize.y).div(2)
+            ],
+            "faceTowardsBorder": template.faceTowardsBorder
         };
     });
 }
 
 CityPainter.prototype.paint = function(area)
@@ -38 +41 @@
     // The city would be much denser if it would test for actual shape intersection or
     // if it would use a custom, more fine-grained obstruction grid
     let tileClass = g_Map.createTileClass();
 
     let processed = new Array(mapSize).fill(0).map(() => new Uint8Array(mapSize));
+    let borderPoints = area.getBorderArea(1);
+
 
     for (let x = 0; x < mapSize; x += 0.5)
         for (let y = 0; y < mapSize; y += 0.5)
         {
             let point = new Vector2D(x, y).rotateAround(this.angle, mapCenter).round();
@@ -53 +58 @@
             for (let template of shuffleArray(templates))
             {
                 if (template.constraint && !template.constraint.allows(point))
                     continue;
 
-                // Randomize building angle while keeping it aligned
-                let buildingAngle = this.angle + randIntInclusive(0, 3) * Math.PI / 2;
+                let buildingAngle = this.getBuildingAngle(point, area, borderPoints, template);
 
                 // Place the entity if all points are within the boundaries and don't collide with the other entities
                 let obstructionCorners = template.obstructionCorners.map(obstructionCorner =>
                     Vector2D.add(point, obstructionCorner.clone().rotate(buildingAngle)));
 
@@ -80 +84 @@
                 templates = templates.filter(template => templateCounts[template.templateName] < template.maxCount);
                 break;
             }
         }
 };
+
+CityPainter.prototype.getBuildingAngle = function(point, area, borderPoints, template)
+{
+    let buildingAngle = this.angle + randIntInclusive(0, 3) * Math.PI / 2;
+    if (!template.faceTowardsBorder)
+        return buildingAngle;
+
+    let isAtBorder = borderPoints.getClosestPointTo(point).distanceToSquared(point) < template.obstructionMaxLengthSquared;
+    if (!isAtBorder)
+        return buildingAngle;
+
+    let mapSize = g_Map.getSize();
+    let borderDistance = Infinity;
+    for (let i = 0; i < 4; ++i)
+    {
+        let angle = this.angle + i * Math.PI / 2;
+        let borderPoint = findPointInDirection(point, new Vector2D(mapSize, 0).rotate(angle).add(point), new AvoidAreasConstraint([area]), 0);
+
+        let distance = point.distanceTo(borderPoint);
+        if (distance >= borderDistance)
+            continue;
+
+        borderDistance = distance;
+        buildingAngle = angle;
+    }
+
+    return buildingAngle;
+};

binaries/data/mods/public/maps/random/rmgen-common/gaia_terrain.js

@@ -588 +588 @@
 /**
  * Returns the first location between startPoint and endPoint that lies within the given heightrange.
  */
 function findLocationInDirectionBasedOnHeight(startPoint, endPoint, minHeight, maxHeight, offset = 0)
 {
-    let stepVec = Vector2D.sub(endPoint, startPoint);
-    let distance = Math.ceil(stepVec.length());
-    stepVec.normalize();
-
-    for (let i = 0; i < distance; ++i)
-    {
-        let pos = Vector2D.add(startPoint, Vector2D.mult(stepVec, i));
-        let ipos = pos.clone().round();
-
-        if (g_Map.validHeight(ipos) &&
-            g_Map.getHeight(ipos) >= minHeight &&
-            g_Map.getHeight(ipos) <= maxHeight)
-            return pos.add(stepVec.mult(offset));
-    }
-
-    return undefined;
+    return findPointInDirection(startPoint, endPoint, new HeightConstraint(minHeight, maxHeight), offset);
 }