Ticket #804: dockbuildifx-07232011.patch

binaries/data/mods/public/gui/session/input.js

@@ -80 +80 @@
 
     if (placementEntity && placementPosition)
     {
-        Engine.GuiInterfaceCall("SetBuildingPlacementPreview", {
+        return Engine.GuiInterfaceCall("SetBuildingPlacementPreview", {
             "template": placementEntity,
             "x": placementPosition.x,
             "z": placementPosition.z,
             "angle": placementAngle
         });
     }
+    
+    return false;
 }
 
 function resetPlacementEntity()
@@ -328 +330 @@
     var selection = g_Selection.toList();
 
     // Use the preview to check it's a valid build location
-    var ok = Engine.GuiInterfaceCall("SetBuildingPlacementPreview", {
-        "template": placementEntity,
-        "x": placementPosition.x,
-        "z": placementPosition.z,
-        "angle": placementAngle
-    });
-    if (!ok)
+    if (!updateBuildingPlacementPreview())
     {
         // invalid location - don't build it
         // TODO: play a sound?
@@ -561 +557 @@
                 placementAngle = defaultPlacementAngle;
             }
 
-            Engine.GuiInterfaceCall("SetBuildingPlacementPreview", {
+            var snapData = Engine.GuiInterfaceCall("GetFoundationSnapData", {
                 "template": placementEntity,
                 "x": placementPosition.x,
-                "z": placementPosition.z,
-                "angle": placementAngle
+                "z": placementPosition.z
             });
-
+            if (snapData.snapped)
+                placementAngle = snapData.angle;
+            
+            updateBuildingPlacementPreview();
             break;
 
         case "mousebuttonup":
@@ -821 +819 @@
         {
         case "mousemotion":
             placementPosition = Engine.GetTerrainAtPoint(ev.x, ev.y);
-            Engine.GuiInterfaceCall("SetBuildingPlacementPreview", {
+            var snapData = Engine.GuiInterfaceCall("GetFoundationSnapData", {
                 "template": placementEntity,
                 "x": placementPosition.x,
-                "z": placementPosition.z,
-                "angle": placementAngle
+                "z": placementPosition.z
             });
+            if (snapData.snapped)
+                placementAngle = snapData.angle;
+            
+            updateBuildingPlacementPreview();
 
             return false; // continue processing mouse motion
 
@@ -855 +856 @@
             {
             case "session.rotate.cw":
                 placementAngle += rotation_step;
-                Engine.GuiInterfaceCall("SetBuildingPlacementPreview", {
-                    "template": placementEntity,
-                    "x": placementPosition.x,
-                    "z": placementPosition.z,
-                    "angle": placementAngle
-                });
+                updateBuildingPlacementPreview();
                 break;
             case "session.rotate.ccw":
                 placementAngle -= rotation_step;
-                Engine.GuiInterfaceCall("SetBuildingPlacementPreview", {
-                    "template": placementEntity,
-                    "x": placementPosition.x,
-                    "z": placementPosition.z,
-                    "angle": placementAngle
-                });
+                updateBuildingPlacementPreview();
                 break;
             }
 

binaries/data/mods/public/simulation/components/BuildRestrictions.js

@@ -5 +5 @@
         "<choice>" +
             "<value>standard</value>" +
             "<value>settlement</value>" +
-        "</choice>" + // TODO: add special types for fields, docks, walls
+            "<value>shore</value>" +
+        "</choice>" + // TODO: add special types for fields, walls
     "</element>" +
     "<element name='Territory'>" +
         "<choice>" +
@@ -48 +49 @@
  * docks must be on shores), which affects the UI and the build permissions
  */
 
+BuildRestrictions.prototype.Init = function()
+{
+};
+ 
 BuildRestrictions.prototype.OnOwnershipChanged = function(msg)
 {
     if (this.template.Category)
@@ -66 +71 @@
     }
 };
 
+BuildRestrictions.prototype.CheckPlacement = function()
+{
+    // First check obstructions and terrain passability
+    var passClassName = "";
+    switch(this.template.PlacementType)
+    {
+    case "shore":
+        passClassName = "building-shore"
+        break;
+        
+    case "standard":
+    case "settlement":
+        passClassName = "building-land"
+        break;
+        
+    default:
+        error("Unknown placement type: "+this.template.PlacementType);
+    }
+
+    var cmpObstruction = Engine.QueryInterface(this.entity, IID_Obstruction);
+    if (!cmpObstruction || !cmpObstruction.IsValidFoundation(passClassName))
+    {
+        return false;   // Fail
+    }
+    
+    // Check special requirements
+    if (this.template.Category == "Dock")
+    {
+        // Dock must be oriented from land facing into water
+        var cmpFootprint = Engine.QueryInterface(this.entity, IID_Footprint);
+        if (!cmpFootprint)
+            return false;   // Fail
+        
+        var shape = cmpFootprint.GetShape();
+        
+        // Get building's footprint
+        var halfX = 0;
+        var halfZ = 0;
+        if (shape.type == "square")
+        {
+            halfX = shape.width/2;
+            halfZ = shape.depth/2;
+        }
+        else if (shape.type == "circle")
+        {   // Approximate as square?
+            halfX = shape.radius;
+            halfZ = shape.radius;
+        }
+
+        var cmpTerrain = Engine.QueryInterface(SYSTEM_ENTITY, IID_Terrain);
+        var cmpWaterMgr = Engine.QueryInterface(SYSTEM_ENTITY, IID_WaterManager);
+        var cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
+        
+        if (!cmpTerrain || !cmpPosition || !cmpWaterMgr)
+            return false;   // Fail
+        
+        var pos = cmpPosition.GetPosition();
+        var ang = cmpPosition.GetRotation().y;
+        var s = Math.sin(ang);
+        var c = Math.cos(ang);
+        if ((cmpTerrain.GetGroundLevel(pos.x + s*halfX, pos.z + c*halfZ)
+                > cmpWaterMgr.GetWaterLevel(pos.x + s*halfX, pos.z + c*halfZ)) || // front
+            (cmpTerrain.GetGroundLevel(pos.x - s*halfX, pos.z - c*halfZ)
+                <= cmpWaterMgr.GetWaterLevel(pos.x - s*halfX, pos.z - c*halfZ)) // back
+        )
+            return false;   // Fail
+    }
+    
+    // Success
+    return true;
+};
+
 BuildRestrictions.prototype.GetCategory = function()
 {
     return this.template.Category;

binaries/data/mods/public/simulation/components/GarrisonHolder.js

@@ -155 +155 @@
         // For now, just move the unit into the middle of the building where it'll probably get stuck
         var cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
         pos = cmpPosition.GetPosition();
-        warn("Can't find free space to ungarrison unit");
+        
+        var cmpPlayer = QueryOwnerInterface(this.entity, IID_Player);
+        var notification = {"player": cmpPlayer.GetPlayerID(), "message": "Can't find free space to ungarrison unit"};
+        var cmpGUIInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
+        cmpGUIInterface.PushNotification(notification);
     }
 
     var cmpNewPosition = Engine.QueryInterface(entity, IID_Position);

binaries/data/mods/public/simulation/components/GuiInterface.js

@@ -468 +468 @@
             pos.SetYRotation(cmd.angle);
         }
 
-        // Check whether it's obstructed by other entities
-        var cmpObstruction = Engine.QueryInterface(ent, IID_Obstruction);
-        var colliding = (cmpObstruction && cmpObstruction.CheckFoundationCollisions());
+        // Check whether it's obstructed by other entities or invalid terrain
+        var cmpBuildRestrictions = Engine.QueryInterface(ent, IID_BuildRestrictions);
+        if (!cmpBuildRestrictions)
+            error("cmpBuildRestrictions null");
+        var placementValid = (cmpBuildRestrictions && cmpBuildRestrictions.CheckPlacement());
 
         // Check whether it's in a visible region
         var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
-        var visible = (cmpRangeManager.GetLosVisibility(ent, player) == "visible");
+        var visible = (cmpRangeManager && cmpRangeManager.GetLosVisibility(ent, player) == "visible");
 
-        var ok = (!colliding && visible);
+        var ok = (placementValid && visible);
 
         // Set it to a red shade if this is an invalid location
         var cmpVisual = Engine.QueryInterface(ent, IID_Visual);
@@ -494 +496 @@
     return false;
 };
 
+GuiInterface.prototype.GetFoundationSnapData = function(player, data)
+{
+    var cmpTemplateMgr = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
+    var template = cmpTemplateMgr.GetTemplate(data.template);
+
+    if (template.BuildRestrictions.Category == "Dock")
+    {
+        // Autorotate to shore
+        var cmpTerrain = Engine.QueryInterface(SYSTEM_ENTITY, IID_Terrain);
+        var norm = cmpTerrain.CalcNormal(data.x, data.z);
+        
+        if (norm.y != 1.0)
+        {
+            return { "snapped": true, "x": data.x, "z": data.z, "angle": Math.atan2(norm.x, norm.z) };
+        }
+    }
+
+    return {"snapped": false};
+};
+
 GuiInterface.prototype.PlaySound = function(player, data)
 {
     // Ignore if no entity was passed
@@ -583 +605 @@
     "SetStatusBars": 1,
     "DisplayRallyPoint": 1,
     "SetBuildingPlacementPreview": 1,
+    "GetFoundationSnapData": 1,
     "PlaySound": 1,
     "FindIdleUnit": 1,
 

binaries/data/mods/public/simulation/components/TrainingQueue.js

@@ -217 +217 @@
             // What should we do here?
             // For now, just move the unit into the middle of the building where it'll probably get stuck
             pos = cmpPosition.GetPosition();
-            warn("Can't find free space to spawn trained unit");
+            
+            var cmpPlayer = QueryOwnerInterface(this.entity, IID_Player);
+            var notification = {"player": cmpPlayer.GetPlayerID(), "message": "Can't find free space to spawn trained unit"};
+            var cmpGUIInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
+            cmpGUIInterface.PushNotification(notification);
         }
 
         var cmpNewPosition = Engine.QueryInterface(ent, IID_Position);

binaries/data/mods/public/simulation/data/pathfinder.xml

@@ -14 +14 @@
     <ship>
       <MinWaterDepth>1</MinWaterDepth>
     </ship>
-    <!-- Building construction classes: -->
+    <!-- Building construction classes:
+    * Land is used for most buildings, which must be away
+        from water and not on cliffs or mountains.
+    * Shore is used for docks, which must be near water and
+        land, yet shallow enough for builders to approach.
+    -->
     <building-land>
       <MaxWaterDepth>0</MaxWaterDepth>
+      <MinShoreDistance>2.0</MinShoreDistance>
       <MaxTerrainSlope>1.0</MaxTerrainSlope>
     </building-land>
+    <building-shore>
+      <MaxShoreDistance>4.0</MaxShoreDistance>
+      <MaxTerrainSlope>1.0</MaxTerrainSlope>
+    </building-shore>
 
   </PassabilityClasses>
   

binaries/data/mods/public/simulation/helpers/Commands.js

@@ -131 +131 @@
 
         // Tentatively create the foundation (we might find later that it's a invalid build command)
         var ent = Engine.AddEntity("foundation|" + cmd.template);
-        // TODO: report errors (e.g. invalid template names)
+        if (ent == INVALID_ENTITY)
+        {
+            // Error (e.g. invalid template names)
+            error("Error creating foundation for '" + cmd.template + "'");
+            break;
+        }
 
         // Move the foundation to the right place
         var cmpPosition = Engine.QueryInterface(ent, IID_Position);
         cmpPosition.JumpTo(cmd.x, cmd.z);
         cmpPosition.SetYRotation(cmd.angle);
 
-        // Check whether it's obstructed by other entities
-        var cmpObstruction = Engine.QueryInterface(ent, IID_Obstruction);
-        if (cmpObstruction && cmpObstruction.CheckFoundationCollisions())
+        // Check whether it's obstructed by other entities or invalid terrain
+        var cmpBuildRestrictions = Engine.QueryInterface(ent, IID_BuildRestrictions);
+        if (!cmpBuildRestrictions || !cmpBuildRestrictions.CheckPlacement())
         {
-            // TODO: report error to player (the building site was obstructed)
-            print("Building site was obstructed\n");
+            var cmpGuiInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface);
+            cmpGuiInterface.PushNotification({ "player": player, "message": "Building site was obstructed" });
 
             // Remove the foundation because the construction was aborted
             Engine.DestroyEntity(ent);

binaries/data/mods/public/simulation/templates/template_structure_military_dock.xml

@@ -7 +7 @@
     <Icon>structures/dock.png</Icon>
   </Identity>
   <BuildRestrictions>
+    <PlacementType>shore</PlacementType>
     <Category>Dock</Category>
   </BuildRestrictions>
   <Cost>

source/simulation2/components/CCmpFootprint.cpp

@@ -22 +22 @@
 
 #include "ICmpObstruction.h"
 #include "ICmpObstructionManager.h"
+#include "ICmpPathfinder.h"
 #include "ICmpPosition.h"
+#include "ICmpUnitMotion.h"
 #include "simulation2/MessageTypes.h"
 #include "maths/FixedVector2D.h"
 
@@ -146 +148 @@
         }
         // else use zero radius
 
+        // Get passability class from UnitMotion
+        CmpPtr<ICmpUnitMotion> cmpUnitMotion(GetSimContext(), spawned);
+        if (cmpUnitMotion.null())
+            return error;
+
+        u16 spawnedPass = cmpUnitMotion->GetPassabilityClass();
+        CmpPtr<ICmpPathfinder> cmpPathfinder(GetSimContext(), SYSTEM_ENTITY);
+        if (cmpPathfinder.null())
+            return error;
+
         // The spawn point should be far enough from this footprint to fit the unit, plus a little gap
         entity_pos_t clearance = spawnedRadius + entity_pos_t::FromInt(2);
 
@@ -168 +180 @@
                 CFixedVector3D pos (initialPos.X + s.Multiply(radius), fixed::Zero(), initialPos.Y + c.Multiply(radius));
 
                 SkipTagObstructionFilter filter(spawnedTag); // ignore collisions with the spawned entity
-                if (!cmpObstructionManager->TestUnitShape(filter, pos.X, pos.Z, spawnedRadius, NULL))
+                if (cmpPathfinder->CheckUnitPlacement(filter, pos.X, pos.Z, spawnedRadius, spawnedPass))
                     return pos; // this position is okay, so return it
             }
         }
@@ -177 +189 @@
             fixed s, c;
             sincos_approx(initialAngle, s, c);
 
-            for (size_t edge = 0; edge < 4; ++edge)
+            // Expand outwards to a max of 4 tiles from foundation
+            for (size_t dist = 0; dist <= 4; ++dist)
             {
-                // Try equally-spaced points along the edge, starting from the middle and expanding outwards in alternating directions
-                const ssize_t numPoints = 9;
-
-                // Compute the direction and length of the current edge
-                CFixedVector2D dir;
-                fixed sx, sy;
-                switch (edge)
+                for (size_t edge = 0; edge < 4; ++edge)
                 {
-                case 0:
-                    dir = CFixedVector2D(c, -s);
-                    sx = m_Size0;
-                    sy = m_Size1;
-                    break;
-                case 1:
-                    dir = CFixedVector2D(-s, -c);
-                    sx = m_Size1;
-                    sy = m_Size0;
-                    break;
-                case 2:
-                    dir = CFixedVector2D(s, c);
-                    sx = m_Size1;
-                    sy = m_Size0;
-                    break;
-                case 3:
-                    dir = CFixedVector2D(-c, s);
-                    sx = m_Size0;
-                    sy = m_Size1;
-                    break;
-                }
-                CFixedVector2D center = initialPos - dir.Perpendicular().Multiply(sy/2 + clearance);
-                dir = dir.Multiply((sx + clearance*2) / (int)(numPoints-1));
+                    // Try equally-spaced points along the edge in alternating directions, starting from the middle
+                    const ssize_t numPoints = 9 + 2*dist;
 
-                for (ssize_t i = 0; i < (numPoints+1)/2; i = (i > 0 ? -i : 1-i)) // [0, +1, -1, +2, -2, ... (np-1)/2, -(np-1)/2]
-                {
-                    CFixedVector2D pos (center + dir*i);
+                    // Compute the direction and length of the current edge
+                    CFixedVector2D dir;
+                    fixed sx, sy;
+                    switch (edge)
+                    {
+                    case 0:
+                        dir = CFixedVector2D(c, -s);
+                        sx = m_Size0;
+                        sy = m_Size1;
+                        break;
+                    case 1:
+                        dir = CFixedVector2D(-s, -c);
+                        sx = m_Size1;
+                        sy = m_Size0;
+                        break;
+                    case 2:
+                        dir = CFixedVector2D(s, c);
+                        sx = m_Size1;
+                        sy = m_Size0;
+                        break;
+                    case 3:
+                        dir = CFixedVector2D(-c, s);
+                        sx = m_Size0;
+                        sy = m_Size1;
+                        break;
+                    }
+                    dir.Normalize(fixed::FromFloat(1.0f + 0.25f*(float)dist));
+                    CFixedVector2D center = initialPos - dir.Perpendicular().Multiply(sy/2 + clearance);
+                    dir = dir.Multiply((sx + clearance*2) / (int)(numPoints-1));
 
-                    SkipTagObstructionFilter filter(spawnedTag); // ignore collisions with the spawned entity
-                    if (!cmpObstructionManager->TestUnitShape(filter, pos.X, pos.Y, spawnedRadius, NULL))
-                        return CFixedVector3D(pos.X, fixed::Zero(), pos.Y); // this position is okay, so return it
+                    for (ssize_t i = 0; i < (numPoints+1)/2; i = (i > 0 ? -i : 1-i)) // [0, +1, -1, +2, -2, ... (np-1)/2, -(np-1)/2]
+                    {
+                        CFixedVector2D pos (center + dir*i);
+
+                        SkipTagObstructionFilter filter(spawnedTag); // ignore collisions with the spawned entity
+                        if (cmpPathfinder->CheckUnitPlacement(filter, pos.X, pos.Y, spawnedRadius, spawnedPass))
+                            return CFixedVector3D(pos.X, fixed::Zero(), pos.Y); // this position is okay, so return it
+                    }
                 }
             }
         }

source/simulation2/components/CCmpObstruction.cpp

@@ -328 +328 @@
             return entity_pos_t::Zero();
     }
 
-    virtual bool CheckFoundationCollisions()
+    virtual bool IsValidFoundation(std::string className)
     {
         CmpPtr<ICmpPosition> cmpPosition(GetSimContext(), GetEntityId());
         if (cmpPosition.null())
@@ -339 +339 @@
 
         CFixedVector2D pos = cmpPosition->GetPosition2D();
 
-        CmpPtr<ICmpObstructionManager> cmpObstructionManager(GetSimContext(), SYSTEM_ENTITY);
-        if (cmpObstructionManager.null())
+        CmpPtr<ICmpPathfinder> cmpPathfinder(GetSimContext(), SYSTEM_ENTITY);
+        if (cmpPathfinder.null())
             return false; // error
 
+        // Get passability class
+        u16 passClass = cmpPathfinder->GetPassabilityClass(className);
+
         // Ignore collisions with self, or with non-foundation-blocking obstructions
         SkipTagFlagsObstructionFilter filter(m_Tag, ICmpObstructionManager::FLAG_BLOCK_FOUNDATION);
 
         if (m_Type == STATIC)
-            return cmpObstructionManager->TestStaticShape(filter, pos.X, pos.Y, cmpPosition->GetRotation().Y, m_Size0, m_Size1, NULL);
+            return cmpPathfinder->CheckBuildingPlacement(filter, pos.X, pos.Y, cmpPosition->GetRotation().Y, m_Size0, m_Size1, passClass);
         else
-            return cmpObstructionManager->TestUnitShape(filter, pos.X, pos.Y, m_Size0, NULL);
+            return cmpPathfinder->CheckUnitPlacement(filter, pos.X, pos.Y, m_Size0, passClass);
     }
 
     virtual std::vector<entity_id_t> GetConstructionCollisions()

source/simulation2/components/CCmpPathfinder.cpp

@@ -374 +374 @@
 
         CTerrain& terrain = GetSimContext().GetTerrain();
 
+        // Compute influence map for shore distance
+        Grid<u16> shoreGrid(m_MapSize, m_MapSize);
         for (u16 j = 0; j < m_MapSize; ++j)
         {
             for (u16 i = 0; i < m_MapSize; ++i)
             {
                 fixed x, z;
                 TileCenter(i, j, x, z);
+                
+                fixed height = terrain.GetExactGroundLevelFixed(x, z);
+                fixed water;
+                if (!cmpWaterMan.null())
+                    water = cmpWaterMan->GetWaterLevel(x, z);
+                fixed depth = water - height;
 
+                if (depth > fixed::Zero() && depth < fixed::FromFloat(1.f))
+                {   // Shore (allowing for precision error)
+                    shoreGrid.set(i, j, 0);
+                }
+                else
+                {
+                    shoreGrid.set(i, j, 32767);
+                }
+            }
+        }
+
+        // Expand influences
+        for (size_t y = 0; y < m_MapSize; ++y)
+        {
+            u16 min = 32767;
+            for (size_t x = 0; x < m_MapSize; ++x)
+            {
+                u16 g = shoreGrid.get(x, y);
+                if (g > min)
+                    shoreGrid.set(x, y, min);
+                else if (g < min)
+                    min = g;
+
+                ++min;
+            }
+            for (size_t x = m_MapSize; x > 0; --x)
+            {
+                u16 g = shoreGrid.get(x-1, y);
+                if (g > min)
+                    shoreGrid.set(x-1, y, min);
+                else if (g < min)
+                    min = g;
+
+                ++min;
+            }
+        }
+        for (size_t x = 0; x < m_MapSize; ++x)
+        {
+            u16 min = 32767;
+            for (size_t y = 0; y < m_MapSize; ++y)
+            {
+                u16 g = shoreGrid.get(x, y);
+                if (g > min)
+                    shoreGrid.set(x, y, min);
+                else if (g < min)
+                    min = g;
+
+                ++min;
+            }
+            for (size_t y = m_MapSize; y > 0; --y)
+            {
+                u16 g = shoreGrid.get(x, y-1);
+                if (g > min)
+                    shoreGrid.set(x, y-1, min);
+                else if (g < min)
+                    min = g;
+
+                ++min;
+            }
+        }
+
+        for (u16 j = 0; j < m_MapSize; ++j)
+        {
+            for (u16 i = 0; i < m_MapSize; ++i)
+            {
+                fixed x, z;
+                TileCenter(i, j, x, z);
+
                 TerrainTile t = 0;
 
                 u8 obstruct = m_ObstructionGrid->get(i, j);
 
-                fixed height = terrain.GetVertexGroundLevelFixed(i, j); // TODO: should use tile centre
+                fixed height = terrain.GetExactGroundLevelFixed(x, z);
 
                 fixed water;
                 if (!cmpWaterMan.null())
@@ -395 +471 @@
 
                 fixed slope = terrain.GetSlopeFixed(i, j);
 
+                fixed shoredist = fixed::FromInt(shoreGrid.get(i, j));
+
                 if (obstruct & ICmpObstructionManager::TILE_OBSTRUCTED_PATHFINDING)
                     t |= 1;
 
@@ -411 +489 @@
                 {
                     for (size_t n = 0; n < m_PassClasses.size(); ++n)
                     {
-                        if (!m_PassClasses[n].IsPassable(depth, slope))
+                        if (!m_PassClasses[n].IsPassable(depth, slope, shoredist))
                             t |= m_PassClasses[n].m_Mask;
                     }
                 }

source/simulation2/components/CCmpPathfinder_Common.h

@@ -96 +96 @@
             m_MaxSlope = node.GetChild("MaxTerrainSlope").ToFixed();
         else
             m_MaxSlope = std::numeric_limits<fixed>::max();
+
+        if (node.GetChild("MinShoreDistance").IsOk())
+            m_MinShore = node.GetChild("MinShoreDistance").ToFixed();
+        else
+            m_MinShore = std::numeric_limits<fixed>::min();
+
+        if (node.GetChild("MaxShoreDistance").IsOk())
+            m_MaxShore = node.GetChild("MaxShoreDistance").ToFixed();
+        else
+            m_MaxShore = std::numeric_limits<fixed>::max();
+
     }
 
-    bool IsPassable(fixed waterdepth, fixed steepness)
+    bool IsPassable(fixed waterdepth, fixed steepness, fixed shoredist)
     {
-        return ((m_MinDepth <= waterdepth && waterdepth <= m_MaxDepth) && (steepness < m_MaxSlope));
+        return ((m_MinDepth <= waterdepth && waterdepth <= m_MaxDepth) && (steepness < m_MaxSlope) && (m_MinShore <= shoredist && shoredist <= m_MaxShore));
     }
 
     ICmpPathfinder::pass_class_t m_Mask;
@@ -108 +119 @@
     fixed m_MinDepth;
     fixed m_MaxDepth;
     fixed m_MaxSlope;
+    fixed m_MinShore;
+    fixed m_MaxShore;
 };
 
 typedef u16 TerrainTile;
@@ -247 +260 @@
 
     virtual bool CheckMovement(const IObstructionTestFilter& filter, entity_pos_t x0, entity_pos_t z0, entity_pos_t x1, entity_pos_t z1, entity_pos_t r, pass_class_t passClass);
 
+    virtual bool CheckUnitPlacement(const IObstructionTestFilter& filter, entity_pos_t x, entity_pos_t z, entity_pos_t r, pass_class_t passClass);
+
+    virtual bool CheckBuildingPlacement(const IObstructionTestFilter& filter, entity_pos_t x, entity_pos_t z, entity_pos_t a, entity_pos_t w, entity_pos_t h, pass_class_t passClass);
+
     virtual void FinishAsyncRequests();
 
     void ProcessLongRequests(const std::vector<AsyncLongPathRequest>& longRequests);

source/simulation2/components/CCmpPathfinder_Vertex.cpp

@@ -892 +892 @@
 
     return visible;
 }
+
+bool CCmpPathfinder::CheckUnitPlacement(const IObstructionTestFilter& filter,
+    entity_pos_t x, entity_pos_t z, entity_pos_t r, pass_class_t passClass)
+{
+    // Check unit obstruction
+    CmpPtr<ICmpObstructionManager> cmpObstructionManager(GetSimContext(), SYSTEM_ENTITY);
+    if (cmpObstructionManager.null())
+        return false;
+
+    if (cmpObstructionManager->TestUnitShape(filter, x, z, r, NULL))
+        return false;
+
+    // Test against terrain:
+
+    UpdateGrid();
+
+    // TODO: Probably a better way to test this
+    u16 i0, j0, i1, j1;
+    NearestTile(x - r, z - r, i0, j0);
+    NearestTile(x + r, z + r, i1, j1);
+    for (u16 i = i0; i <= i1; ++i)
+    {
+        for (u16 j = j0; j <= j1; ++j)
+        {
+            if (!IS_TERRAIN_PASSABLE(m_Grid->get(i,j), passClass))
+            {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+bool CCmpPathfinder::CheckBuildingPlacement(const IObstructionTestFilter& filter,
+    entity_pos_t x, entity_pos_t z, entity_pos_t a, entity_pos_t w,
+    entity_pos_t h, pass_class_t passClass)
+{
+    // Check unit obstruction
+    CmpPtr<ICmpObstructionManager> cmpObstructionManager(GetSimContext(), SYSTEM_ENTITY);
+    if (cmpObstructionManager.null())
+        return false;
+
+    if (cmpObstructionManager->TestStaticShape(filter, x, z, a, w, h, NULL))
+        return false;
+
+    // Test against terrain:
+
+    UpdateGrid();
+
+    // TODO: Probably a better way to test this
+    u16 i0, j0, i1, j1;
+    NearestTile(x - w/2, z - h/2, i0, j0);
+    NearestTile(x + w/2, z + h/2, i1, j1);
+    for (u16 i = i0; i <= i1; ++i)
+    {
+        for (u16 j = j0; j <= j1; ++j)
+        {
+            if (!IS_TERRAIN_PASSABLE(m_Grid->get(i,j), passClass))
+            {
+                return false;
+            }
+        }
+    }
+    return true;
+}

source/simulation2/components/CCmpTemplateManager.cpp

@@ -453 +453 @@
     permittedComponentTypes.insert("Footprint");
     permittedComponentTypes.insert("Obstruction");
     permittedComponentTypes.insert("Decay");
+    permittedComponentTypes.insert("BuildRestrictions");
 
     // Need these for the Actor Viewer:
     permittedComponentTypes.insert("Attack");

source/simulation2/components/CCmpUnitMotion.cpp

@@ -400 +400 @@
         return m_RunSpeed;
     }
 
+    virtual u16 GetPassabilityClass()
+    {
+        return m_PassClass;
+    }
+
     virtual void SetSpeed(fixed speed)
     {
         m_Speed = speed;

source/simulation2/components/ICmpObstruction.cpp

@@ -23 +23 @@
 
 BEGIN_INTERFACE_WRAPPER(Obstruction)
 DEFINE_INTERFACE_METHOD_0("GetUnitRadius", entity_pos_t, ICmpObstruction, GetUnitRadius)
-DEFINE_INTERFACE_METHOD_0("CheckFoundationCollisions", bool, ICmpObstruction, CheckFoundationCollisions)
+DEFINE_INTERFACE_METHOD_1("IsValidFoundation", bool, ICmpObstruction, IsValidFoundation, std::string)
 DEFINE_INTERFACE_METHOD_0("GetConstructionCollisions", std::vector<entity_id_t>, ICmpObstruction, GetConstructionCollisions)
 DEFINE_INTERFACE_METHOD_1("SetActive", void, ICmpObstruction, SetActive, bool)
 DEFINE_INTERFACE_METHOD_1("SetDisableBlockMovementPathfinding", void, ICmpObstruction, SetDisableBlockMovementPathfinding, bool)

source/simulation2/components/ICmpObstruction.h

@@ -44 +44 @@
     /**
      * Test whether this entity is colliding with any obstruction that are set to
      * block the creation of foundations.
-     * @return true if there is a collision
+     * @return true if foundation is valid (not obstructed)
      */
-    virtual bool CheckFoundationCollisions() = 0;
+    virtual bool IsValidFoundation(std::string className) = 0;
 
     /**
      * Returns a list of entities that are colliding with this entity, and that
      * are set to block construction.
-     * @return true if there is a collision
+     * @return vector of blocking entities
      */
     virtual std::vector<entity_id_t> GetConstructionCollisions() = 0;
 

source/simulation2/components/ICmpPathfinder.h

@@ -150 +150 @@
     virtual bool CheckMovement(const IObstructionTestFilter& filter, entity_pos_t x0, entity_pos_t z0, entity_pos_t x1, entity_pos_t z1, entity_pos_t r, pass_class_t passClass) = 0;
 
     /**
+     * Check whether a unit placed here is valid and doesn't hit any obstructions
+     * or impassable terrain.
+     * Returns true if the placement is okay.
+     */
+    virtual bool CheckUnitPlacement(const IObstructionTestFilter& filter, entity_pos_t x, entity_pos_t z, entity_pos_t r, pass_class_t passClass) = 0;
+
+    /**
+     * Check whether a building placed here is valid and doesn't hit any obstructions
+     * or impassable terrain.
+     * Returns true if the placement is okay.
+     */
+    virtual bool CheckBuildingPlacement(const IObstructionTestFilter& filter, entity_pos_t x, entity_pos_t z, entity_pos_t a, entity_pos_t w, entity_pos_t h, pass_class_t passClass) = 0;
+
+    /**
      * Toggle the storage and rendering of debug info.
      */
     virtual void SetDebugOverlay(bool enabled) = 0;

source/simulation2/components/ICmpUnitMotion.cpp

@@ -86 +86 @@
         return m_Script.Call<fixed>("GetRunSpeed");
     }
 
+    virtual u16 GetPassabilityClass()
+    {
+        return m_Script.Call<u16>("GetPassabilityClass");
+    }
+
     virtual void SetUnitRadius(fixed radius)
     {
         m_Script.CallVoid("SetUnitRadius", radius);

source/simulation2/components/ICmpUnitMotion.h

@@ -93 +93 @@
     virtual fixed GetRunSpeed() = 0;
 
     /**
+     * Get the unit's passability class.
+     */
+    virtual u16 GetPassabilityClass() = 0;
+
+    /**
      * Override the default obstruction radius, used for planning paths and checking for collisions.
      * Bad things may happen if this entity has an active Obstruction component with a larger
      * radius. (This is intended primarily for formation controllers.)