Ticket #21: 21.2.patch

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

@@ -119 +119 @@
     this.buildMultiplier = Math.pow(this.numRecentBuilders, 0.7) / this.numRecentBuilders;
 }
 
+Foundation.prototype.FlattenBuildingArea = function()
+{
+        var cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
+        var pos = cmpPosition.GetPosition();
+        var rot = cmpPosition.GetRotation();
+    
+        var cmpFootprint = Engine.QueryInterface(this.entity, IID_Footprint);
+        var shape = cmpFootprint.GetShape();
+        var width, depth = 0;
+    
+        if (shape.type == "square")
+        {
+            width = shape.width;
+            depth = shape.depth;
+    }
+        else if (shape.type == "circle")
+        {
+            width = depth = shape.radius * 2;
+    }
+    
+        var xm = pos.x + width / 2 * Math.sin(rot.y);
+        var zm = pos.z + depth / 2 * Math.sin(rot.y);
+
+        var cmpTerrain = Engine.QueryInterface(SYSTEM_ENTITY, IID_Terrain);
+        var height = cmpTerrain.GetGroundLevel(xm, zm);
+    
+        cmpTerrain.SetGroundLevelRegion(height, pos.x, pos.z, width, depth, rot.y);
+}
+
 /**
  * Perform some number of seconds of construction work.
  * Returns true if the construction is completed.
@@ -177 +206 @@
         }
 
         this.committed = true;
+
+            // Now that we're committed, flatten ground under foundation
+            this.FlattenBuildingArea();
     }
 
     // Calculate the amount of progress that will be added (where 1.0 = completion)

source/graphics/Terrain.cpp

@@ -423 +423 @@
     // in handling triangulation properly
 }
 
+void CTerrain::SetExactGroundLevelFixed(fixed new_y, fixed x, fixed z)
+{
+    // Clamp to size-2 so we can use the tiles (xi,zi)-(xi+1,zi+1)
+    const ssize_t xi = clamp((ssize_t)(x / (int)TERRAIN_TILE_SIZE).ToInt_RoundToZero(), (ssize_t)0, m_MapSize-2);
+    const ssize_t zi = clamp((ssize_t)(z / (int)TERRAIN_TILE_SIZE).ToInt_RoundToZero(), (ssize_t)0, m_MapSize-2);
+
+    m_Heightmap[zi*m_MapSize + xi] = new_y.ToInt_RoundToZero() / HEIGHT_SCALE;
+    m_Heightmap[(zi+1)*m_MapSize + xi] = new_y.ToInt_RoundToZero() / HEIGHT_SCALE;
+    m_Heightmap[zi*m_MapSize + (xi+1)] = new_y.ToInt_RoundToZero() / HEIGHT_SCALE;
+    m_Heightmap[(zi+1)*m_MapSize + (xi+1)] = new_y.ToInt_RoundToZero() / HEIGHT_SCALE;
+}
+
 bool CTerrain::GetTriangulationDir(ssize_t i, ssize_t j) const
 {
     // Clamp to size-2 so we can use the tiles (i,j)-(i+1,j+1)

source/graphics/Terrain.h

@@ -85 +85 @@
     fixed GetVertexGroundLevelFixed(ssize_t i, ssize_t j) const;
     float GetExactGroundLevel(float x, float z) const;
     fixed GetExactGroundLevelFixed(fixed x, fixed z) const;
+    void SetExactGroundLevelFixed(fixed new_y, fixed x, fixed z);
     float GetFilteredGroundLevel(float x, float z, float radius) const;
 
     // get the approximate slope (0 = horizontal, 0.5 = 30 degrees, 1.0 = 45 degrees, etc)

source/simulation2/components/CCmpTerrain.cpp

@@ -25 +25 @@
 #include "simulation2/MessageTypes.h"
 
 #include "graphics/Terrain.h"
+#include "graphics/RenderableObject.h"
 
 class CCmpTerrain : public ICmpTerrain
 {
@@ -79 +80 @@
         return m_Terrain->GetExactGroundLevelFixed(x, z);
     }
 
+    virtual void SetGroundLevelRegion(entity_pos_t new_y, entity_pos_t x, entity_pos_t z, fixed width, fixed depth, fixed y_rot)
+    {
+        // Initialize dirty region to the center of the given region (coordinates in tile space)
+        ssize_t xi = x.ToInt_RoundToZero();
+        ssize_t zi = z.ToInt_RoundToZero();
+
+        ssize_t x_min = xi, z_min = zi, x_max = xi + 1, z_max = zi + 1;
+
+        // Loop through every integral point in the region
+        // This treats the region as a grid of points with a cell size of 1
+        for(fixed i = fixed::FromInt(-1); i < width + fixed::FromInt(1); i += fixed::FromInt(1))
+        {
+            for(fixed j = fixed::FromInt(-1); j < width + fixed::FromInt(1); j += fixed::FromInt(1))
+            {
+                // Create a vector corresponding to the top left corner of the region
+                CFixedVector2D v(width / -2 + i, depth / -2 + j);
+                // Rotate that vector by the rotation of the region
+                v = v.Rotate(y_rot);
+
+                fixed height = new_y;
+
+                // Smooth elevation on surrounding tiles by averaging
+                if(i < fixed::FromInt(0) || i > width || j < fixed::FromInt(0) || j > depth)
+                {
+                    fixed current_height = m_Terrain->GetExactGroundLevelFixed(v.X + x, v.Y + z);
+                    height = (current_height + new_y) / 2;
+                }
+
+                m_Terrain->SetExactGroundLevelFixed(height, v.X + x, v.Y + z);
+
+                // Calculate if the current point lies outside known dirty region, converting to tile space
+                ssize_t x_low = (v.X + x).ToInt_RoundToZero() / TERRAIN_TILE_SIZE;
+                ssize_t x_high = (v.X + x).ToInt_RoundToInfinity() / TERRAIN_TILE_SIZE;
+                ssize_t z_low = (v.Y + z).ToInt_RoundToZero() / TERRAIN_TILE_SIZE;
+                ssize_t z_high = (v.Y + z).ToInt_RoundToInfinity() / TERRAIN_TILE_SIZE;
+
+                if(x_low < x_min)
+                {
+                    x_min = x_low;
+                }
+                else if(x_high > x_max)
+                {
+                    x_max = x_high;
+                }
+
+                if(z_low < z_min)
+                {
+                    z_min = z_low;
+                }
+                else if(z_high > z_max)
+                {
+                    z_max = z_high;
+                }
+            }
+        }
+
+        // Allow changes to be displayed
+        // As noted in Terrain.h, this needs to include adjacent tiles that blend in to this one
+        m_Terrain->MakeDirty(x_min - 1, z_min - 1, x_max + 2, z_max + 2, RENDERDATA_UPDATE_VERTICES);
+
+        // Alert any components that are interested that the terrain changes
+        CmpPtr<ICmpTerrain> cmpTerrain(GetSimContext(), SYSTEM_ENTITY);
+        if (cmpTerrain)
+            cmpTerrain->MakeDirty(x_min, z_min, x_max, z_max);
+
+    }
+
     virtual float GetExactGroundLevel(float x, float z)
     {
         return m_Terrain->GetExactGroundLevel(x, z);

source/simulation2/components/ICmpTerrain.cpp

@@ -23 +23 @@
 
 BEGIN_INTERFACE_WRAPPER(Terrain)
 DEFINE_INTERFACE_METHOD_2("GetGroundLevel", entity_pos_t, ICmpTerrain, GetGroundLevel, entity_pos_t, entity_pos_t)
+DEFINE_INTERFACE_METHOD_6("SetGroundLevelRegion", void, ICmpTerrain, SetGroundLevelRegion, entity_pos_t, entity_pos_t, entity_pos_t, fixed, fixed, fixed)
 DEFINE_INTERFACE_METHOD_2("CalcNormal", CFixedVector3D, ICmpTerrain, CalcNormal, entity_pos_t, entity_pos_t)
 END_INTERFACE_WRAPPER(Terrain)

source/simulation2/components/ICmpTerrain.h

@@ -35 +35 @@
 
     virtual entity_pos_t GetGroundLevel(entity_pos_t x, entity_pos_t z) = 0;
 
+    virtual void SetGroundLevelRegion(entity_pos_t new_y, entity_pos_t x, entity_pos_t z, fixed width, fixed depth, fixed y_rot) = 0;
+
     virtual float GetExactGroundLevel(float x, float z) = 0;
 
     /**