Ticket #1109: 1109_Recenter_Undo.patch

source/tools/atlas/AtlasUI/CustomControls/MapResizeDialog/MapResizeDialog.cpp

@@ -36 +36 @@
 
     SetTitle(_("Resize map"));
     wxSizer* sizer = new wxBoxSizer(wxVERTICAL);
-    wxStaticText* label = new wxStaticText(this, wxID_ANY, _("Select new map size. WARNING: This probably only works reliably on blank maps."), wxDefaultPosition, wxDefaultSize);
+    wxStaticText* label = new wxStaticText(this, wxID_ANY, _("Select new map size."), wxDefaultPosition, wxDefaultSize);
     sizer->Add(label, wxSizerFlags().Align(wxALIGN_CENTER_HORIZONTAL).Border(wxALL, 10));
 
     wxBoxSizer* listAndMap = new wxBoxSizer(wxHORIZONTAL);

source/tools/atlas/GameInterface/Handlers/MapHandlers.cpp

@@ -430 +430 @@
     int m_OldPatches, m_NewPatches;
     int m_OffsetX, m_OffsetY;
 
+    u16* m_Heightmap; 
+    CPatch* m_Patches;
+
     std::vector<DeletedObject> m_DeletedObjects;
 
     std::vector<std::pair<entity_id_t, CFixedVector3D>> m_OldPositions;
@@ -439 +442 @@
     {
     }
 
+    ~cResizeMap()
+    {
+        delete m_Heightmap;
+        delete m_Patches;
+    }
+
     void MakeDirty()
     {
         CmpPtr<ICmpTerrain> cmpTerrain(*g_Game->GetSimulation2(), SYSTEM_ENTITY);
@@ -524 +533 @@
             m_OffsetX = msg->offsetX / PATCH_SIZE;
             // Need to flip direction of vertical offset, due to screen mapping order.
             m_OffsetY = -(msg->offsetY / PATCH_SIZE);
+
+            CTerrain* terrain = cmpTerrain->GetCTerrain();
+            m_Heightmap = new u16[(m_OldPatches * PATCH_SIZE + 1) * (m_OldPatches * PATCH_SIZE + 1)];
+            std::copy_n(terrain->GetHeightMap(), (m_OldPatches * PATCH_SIZE + 1) * (m_OldPatches * PATCH_SIZE + 1), m_Heightmap);
+            m_Patches = new CPatch[m_OldPatches * m_OldPatches];
+            for (ssize_t j = 0; j < m_OldPatches; ++j) {
+                for (ssize_t i = 0; i < m_OldPatches; ++i)
+                {
+                    CPatch& src = *(terrain->GetPatch(i, j));
+                    CPatch& dst = m_Patches[j * m_OldPatches + i];
+                    std::copy_n(&(src.m_MiniPatches[0][0]), PATCH_SIZE * PATCH_SIZE, &(dst.m_MiniPatches[0][0]));
+                }
+            }
         }
 
         const int radiusInTerrainUnits = m_NewPatches * PATCH_SIZE * TERRAIN_TILE_SIZE / 2 * (1.f - 1e-6f);
@@ -579 +601 @@
 
     void Undo()
     {
-        ResizeTerrain(m_OldPatches, -m_OffsetX, -m_OffsetY);
+        if (m_Heightmap == nullptr || m_Patches == nullptr)
+        {   
+            // If there previously was no data, just resize to old (probably not originally valid).
+            ResizeTerrain(m_OldPatches, -m_OffsetX, -m_OffsetY);
+        }
+        else
+        {
+            CSimulation2& sim = *g_Game->GetSimulation2();
+            CmpPtr<ICmpTerrain> cmpTerrain(sim, SYSTEM_ENTITY);
+            CTerrain* terrain = cmpTerrain->GetCTerrain();
+            
+            terrain->Initialize(m_OldPatches, m_Heightmap);
+            // Copy terrain data back.
+            for (ssize_t j = 0; j < m_OldPatches; ++j) {
+                for (ssize_t i = 0; i < m_OldPatches; ++i)
+                {
+                    CPatch& src = m_Patches[j * m_OldPatches + i];
+                    CPatch& dst = *(terrain->GetPatch(i, j));
+                    std::copy_n(&(src.m_MiniPatches[0][0]), PATCH_SIZE * PATCH_SIZE, &(dst.m_MiniPatches[0][0]));
+                }
+            }
+        }
         UndeleteAll(m_DeletedObjects);
         SetPosition(m_OldPositions);
         MakeDirty();

source/tools/atlas/GameInterface/Handlers/MapHandlers.cpp

@@ -432 +432 @@
 
     std::vector<DeletedObject> m_DeletedObjects;
 
-    std::map<entity_id_t, CFixedVector3D> m_OldPositions;
-    std::map<entity_id_t, CFixedVector3D> m_NewPositions;
+    std::vector<std::pair<entity_id_t, CFixedVector3D>> m_OldPositions;
+    std::vector<std::pair<entity_id_t, CFixedVector3D>> m_NewPositions;
 
     cResizeMap()
     {
@@ -493 +493 @@
         }
     }
 
-    void SetPosition(const std::map<entity_id_t, CFixedVector3D>& movedObjects)
+    void SetPosition(const std::vector<std::pair<entity_id_t, CFixedVector3D>>& movedObjects)
     {
         for (auto const& kv : movedObjects)
         {
@@ -547 +547 @@
             {
                 CFixedVector3D position = cmpPosition->GetPosition();
 
-                m_NewPositions[entityId] = position + offset;
-                m_OldPositions[entityId] = position;
+                m_NewPositions.emplace_back(entityId, position + offset);
+                m_OldPositions.emplace_back(entityId, position);
             }
             else
             {

source/tools/atlas/GameInterface/Handlers/MapHandlers.cpp

@@ -18 +18 @@
 #include "precompiled.h"
 
 #include "MessageHandler.h"
+#include "../MessagePasser.h"
 #include "../GameLoop.h"
 #include "../CommandProc.h"
 
@@ -42 +43 @@
 #include "renderer/WaterManager.h"
 #include "scriptinterface/ScriptInterface.h"
 #include "simulation2/Simulation2.h"
+#include "simulation2/components/ICmpOwnership.h"
 #include "simulation2/components/ICmpPlayer.h"
 #include "simulation2/components/ICmpPlayerManager.h"
 #include "simulation2/components/ICmpPosition.h"
 #include "simulation2/components/ICmpRangeManager.h"
+#include "simulation2/components/ICmpTemplateManager.h"
 #include "simulation2/components/ICmpTerrain.h"
 #include "simulation2/system/ParamNode.h"
 
@@ -402 +405 @@
 
 BEGIN_COMMAND(ResizeMap)
 {
-    int m_OldTiles, m_NewTiles;
+    bool Within(const CFixedVector3D& test, const int centerX, const int centerZ, const int radius)
+    {
+        int dx = abs(test.X.ToInt_RoundToZero() - centerX);
+        if (dx > radius)
+            return false;
+        int dz = abs(test.Z.ToInt_RoundToZero() - centerZ);
+        if (dz > radius)
+            return false;
+        if (dx + dz <= radius)
+            return true;
+        return (dx * dx + dz * dz <= radius * radius);
+    }
+
+    struct DeletedObject
+    {
+        entity_id_t entityId;
+        CStr templateName;
+        int32_t owner;
+        CFixedVector3D pos;
+        CFixedVector3D rot;
+    };
+
+    int m_OldPatches, m_NewPatches;
     int m_OffsetX, m_OffsetY;
 
+    std::vector<DeletedObject> m_DeletedObjects;
+
+    std::map<entity_id_t, CFixedVector3D> m_OldPositions;
+    std::map<entity_id_t, CFixedVector3D> m_NewPositions;
+
     cResizeMap()
     {
     }
@@ -420 +450 @@
         g_Game->GetView()->GetLOSTexture().MakeDirty();
     }
 
-    void ResizeTerrain(int tiles, int offsetX, int offsetY)
+    void ResizeTerrain(int patches, int offsetX, int offsetY)
     {
         CTerrain* terrain = g_Game->GetWorld()->GetTerrain();
+        terrain->ResizeRecenter(patches, offsetX, offsetY);
+    }
+    
+    void DeleteAll(const std::vector<DeletedObject>& deletedObjects)
+    {
+        for (const DeletedObject& deleted : deletedObjects) {
+            g_Game->GetSimulation2()->DestroyEntity(deleted.entityId);
+        }
+
+        g_Game->GetSimulation2()->FlushDestroyedEntities();
+    }
 
-        // Need to flip offset of vertical offset, due to screen mapping order.
-        terrain->ResizeRecenter(tiles / PATCH_SIZE, offsetX / PATCH_SIZE, -offsetY / PATCH_SIZE);
+    void UndeleteAll(const std::vector<DeletedObject>& deletedObjects)
+    {
+        CSimulation2& sim = *g_Game->GetSimulation2();
 
-        MakeDirty();
+        for (const DeletedObject& deleted : deletedObjects)
+        {
+            entity_id_t ent = sim.AddEntity(deleted.templateName.FromUTF8(), deleted.entityId);
+            if (ent == INVALID_ENTITY)
+            {
+                LOGERROR("Failed to load entity template '%s'", deleted.templateName.c_str());
+            }
+            else
+            {
+                CmpPtr<ICmpPosition> cmpPosition(sim, deleted.entityId);
+                if (cmpPosition)
+                {
+                    cmpPosition->JumpTo(deleted.pos.X, deleted.pos.Z);
+                    cmpPosition->SetXZRotation(deleted.rot.X, deleted.rot.Z);
+                    cmpPosition->SetYRotation(deleted.rot.Y);
+                }
+
+                CmpPtr<ICmpOwnership> cmpOwnership(sim, deleted.entityId);
+                if (cmpOwnership)
+                    cmpOwnership->SetOwner(deleted.owner);
+            }
+        }
+    }
+
+    void SetPosition(const std::map<entity_id_t, CFixedVector3D>& movedObjects)
+    {
+        for (auto const& kv : movedObjects)
+        {
+            entity_id_t id = kv.first;
+            CFixedVector3D position = kv.second;
+            CmpPtr<ICmpPosition> cmpPosition(*g_Game->GetSimulation2(), id);
+            ENSURE(cmpPosition);
+            cmpPosition->JumpTo(position.X, position.Z);
+        }
     }
 
     void Do()
     {
-        CmpPtr<ICmpTerrain> cmpTerrain(*g_Game->GetSimulation2(), SYSTEM_ENTITY);
+        CSimulation2& sim = *g_Game->GetSimulation2();
+        CmpPtr<ICmpTemplateManager> cmpTemplateManager(sim, SYSTEM_ENTITY);
+        ENSURE(cmpTemplateManager);
+
+        CmpPtr<ICmpTerrain> cmpTerrain(sim, SYSTEM_ENTITY);
         if (!cmpTerrain)
         {
-            m_OldTiles = m_NewTiles = 0;
+            m_OldPatches = m_NewPatches = 0;
             m_OffsetX = m_OffsetY = 0;
         }
         else
         {
-            m_OldTiles = (int)cmpTerrain->GetTilesPerSide();
-            m_NewTiles = msg->tiles;
-            m_OffsetX = msg->offsetX;
-            m_OffsetY = msg->offsetY;
+            m_OldPatches = (int)cmpTerrain->GetTilesPerSide() / PATCH_SIZE;
+            m_NewPatches = msg->tiles / PATCH_SIZE;
+            m_OffsetX = msg->offsetX / PATCH_SIZE;
+            // Need to flip direction of vertical offset, due to screen mapping order.
+            m_OffsetY = -(msg->offsetY / PATCH_SIZE);
+        }
+
+        const int radiusInTerrainUnits = m_NewPatches * PATCH_SIZE * TERRAIN_TILE_SIZE / 2 * (1.f - 1e-6f);
+        // Opposite direction offset, as we move the destination onto the source, not the source into the destination.
+        const int mapCenterX = (m_OldPatches / 2 - m_OffsetX) * PATCH_SIZE * TERRAIN_TILE_SIZE;
+        const int mapCenterZ = (m_OldPatches / 2 - m_OffsetY) * PATCH_SIZE * TERRAIN_TILE_SIZE;
+        // The offset to move units by is opposite the direction the map is moved, and from the corner.
+        const int offsetX = ((m_NewPatches - m_OldPatches) / 2 + m_OffsetX) * PATCH_SIZE * TERRAIN_TILE_SIZE;
+        const int offsetZ = ((m_NewPatches - m_OldPatches) / 2 + m_OffsetY) * PATCH_SIZE * TERRAIN_TILE_SIZE;
+        const CFixedVector3D offset = CFixedVector3D(fixed::FromInt(offsetX), fixed::FromInt(0), fixed::FromInt(offsetZ));
+
+        const CSimulation2::InterfaceListUnordered& ents = sim.GetEntitiesWithInterfaceUnordered(IID_Selectable);
+
+        for (auto const& kv : ents) {
+
+            const entity_id_t entityId = kv.first;
+
+            CmpPtr<ICmpPosition> cmpPosition(sim, entityId);
+
+            if (cmpPosition && cmpPosition->IsInWorld() && Within(cmpPosition->GetPosition(), mapCenterX, mapCenterZ, radiusInTerrainUnits))
+            {
+                CFixedVector3D position = cmpPosition->GetPosition();
+
+                m_NewPositions[entityId] = position + offset;
+                m_OldPositions[entityId] = position;
+            }
+            else
+            {
+                DeletedObject deleted;
+                deleted.entityId = entityId;
+                deleted.templateName = cmpTemplateManager->GetCurrentTemplateName(entityId);
+
+                // If the entity has a position, but the ending position is not valid;
+                if (cmpPosition)
+                {
+                    deleted.pos = cmpPosition->GetPosition();
+                    deleted.rot = cmpPosition->GetRotation();
+                }
+
+                CmpPtr<ICmpOwnership> cmpOwnership(sim, entityId);
+                if (cmpOwnership)
+                    deleted.owner = cmpOwnership->GetOwner();
+
+                m_DeletedObjects.push_back(deleted);
+            }
         }
 
-        ResizeTerrain(m_NewTiles, m_OffsetX, m_OffsetY);
+        DeleteAll(m_DeletedObjects);
+        ResizeTerrain(m_NewPatches, m_OffsetX, m_OffsetY);
+        SetPosition(m_NewPositions);
+        MakeDirty();
     }
 
     void Undo()
     {
-        ResizeTerrain(m_OldTiles, -m_OffsetX, -m_OffsetY);
+        ResizeTerrain(m_OldPatches, -m_OffsetX, -m_OffsetY);
+        UndeleteAll(m_DeletedObjects);
+        SetPosition(m_OldPositions);
+        MakeDirty();
     }
 
     void Redo()
     {
-        ResizeTerrain(m_NewTiles, m_OffsetX, m_OffsetY);
+        DeleteAll(m_DeletedObjects);
+        ResizeTerrain(m_NewPatches, m_OffsetX, m_OffsetY);
+        SetPosition(m_NewPositions);
+        MakeDirty();
     }
 };
 END_COMMAND(ResizeMap)

source/graphics/Terrain.cpp

@@ -497 +497 @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-// Resize: resize this terrain to the given size (in patches per side)
-void CTerrain::Resize(ssize_t size)
+// Resize/Recenter: resize this terrain to the given size (in patches per side).
+// The offset is in patches from the center of the source.
+void CTerrain::ResizeRecenter(ssize_t size, int horizontalOffset, int verticalOffset)
 {
-    if (size==m_MapSizePatches) {
-        // inexplicable request to resize terrain to the same size .. ignore it
+    if (size == m_MapSizePatches &&
+        horizontalOffset == 0 && 
+        verticalOffset == 0) {
+        // inexplicable request to resize terrain to the same size and location .. ignore it
         return;
     }
 
-    if (!m_Heightmap) {
-        // not yet created a terrain; build a default terrain of the given size now
-        Initialize(size,0);
+    if (!m_Heightmap ||
+        std::abs(horizontalOffset) > std::max(size, m_MapSizePatches) / 2 ||
+        std::abs(verticalOffset) > std::max(size, m_MapSizePatches) / 2) {
+        // not yet created a terrain, or offsetting outside the current source; 
+        // build a default terrain of the given size now
+        Initialize(size, 0);
         return;
     }
 
     // allocate data for new terrain
-    ssize_t newMapSize=size*PATCH_SIZE+1;
-    u16* newHeightmap=new u16[newMapSize*newMapSize];
-    CPatch* newPatches=new CPatch[size*size];
-
-    if (size>m_MapSizePatches) {
-        // new map is bigger than old one - zero the heightmap so we don't get uninitialised
-        // height data along the expanded edges
-        memset(newHeightmap,0,newMapSize*newMapSize*sizeof(u16));
-    }
+    ssize_t newMapSize = size * PATCH_SIZE + 1;
+    u16* newHeightmap = new u16[newMapSize * newMapSize];
+    CPatch* newPatches = new CPatch[size * size];
 
-    // now copy over rows of data
-    u16* src=m_Heightmap;
-    u16* dst=newHeightmap;
-    ssize_t copysize=std::min(newMapSize, m_MapSize);
-    for (ssize_t j=0;j<copysize;j++) {
-        memcpy(dst,src,copysize*sizeof(u16));
-        dst+=copysize;
-        src+=m_MapSize;
-        if (newMapSize>m_MapSize) {
-            // extend the last height to the end of the row
-            for (size_t i=0;i<newMapSize-(size_t)m_MapSize;i++) {
-                *dst++=*(src-1);
-            }
-        }
-    }
+    // Restate center offset as a window over destination.
+    // This has the effect of always considering the source to be the same size or smaller.
+    const ssize_t upperLeftX = std::max(0, (int(size) - int(m_MapSizePatches)) / 2 + horizontalOffset);
+    const ssize_t upperLeftZ = std::max(0, (int(size) - int(m_MapSizePatches)) / 2 + verticalOffset);
+    const ssize_t width = std::min(size, (int(size) - int(m_MapSizePatches)) / 2 + horizontalOffset + m_MapSizePatches) - upperLeftX;
+    const ssize_t height = std::min(size, (int(size) - int(m_MapSizePatches)) / 2 + verticalOffset + m_MapSizePatches) - upperLeftZ;
 
+    const ssize_t upperLeftXSource = std::max(0, (int(m_MapSizePatches) - int(size)) / 2 - horizontalOffset);
+    const ssize_t upperLeftZSource = std::max(0, (int(m_MapSizePatches) - int(size)) / 2 - verticalOffset);
 
-    if (newMapSize>m_MapSize) {
-        // copy over heights of the last row to any remaining rows
-        src=newHeightmap+((m_MapSize-1)*newMapSize);
-        dst=src+newMapSize;
-        for (ssize_t i=0;i<newMapSize-m_MapSize;i++) {
-            memcpy(dst,src,newMapSize*sizeof(u16));
-            dst+=newMapSize;
-        }
+    for (ssize_t j = upperLeftZ * PATCH_SIZE; j < (upperLeftZ + height) * PATCH_SIZE + 1; ++j)
+    {
+        u16* dst = newHeightmap + j * newMapSize;
+        u16* src = m_Heightmap + (upperLeftZSource * PATCH_SIZE + (j - upperLeftZ * PATCH_SIZE)) * m_MapSize + upperLeftXSource * PATCH_SIZE;
+
+        dst = std::fill_n(dst, upperLeftX * PATCH_SIZE, *src);
+        dst = std::copy_n(src, width * PATCH_SIZE + 1, dst);
+        std::fill_n(dst, newMapSize - (upperLeftX + width) * PATCH_SIZE, *(src + (width * PATCH_SIZE + 1) - 1));
+    }
+    // Copy over heights from preceding/succeeding rows
+    for (ssize_t j = 0; j < upperLeftZ * PATCH_SIZE; ++j)
+    {
+        u16* dst = newHeightmap + j * newMapSize;
+        u16* src = newHeightmap + upperLeftZ * PATCH_SIZE * newMapSize;
+        std::copy_n(src, newMapSize, dst);
+    }
+    for (ssize_t j = (upperLeftZ + height)*PATCH_SIZE + 1; j < newMapSize; ++j)
+    {
+        u16* dst = newHeightmap + j * newMapSize;
+        u16* src = newHeightmap + (upperLeftZ + height) * PATCH_SIZE * newMapSize;
+        std::copy_n(src, newMapSize, dst);
     }
 
     // now build new patches
-    for (ssize_t j=0;j<size;j++) {
-        for (ssize_t i=0;i<size;i++) {
+    for (ssize_t j = upperLeftZ; j < upperLeftZ + height; ++j) {
+        for (ssize_t i = upperLeftX; i < upperLeftX + width; ++i)
+        {
             // copy over texture data from existing tiles, if possible
-            if (i<m_MapSizePatches && j<m_MapSizePatches) {
-                memcpy(newPatches[j*size+i].m_MiniPatches,m_Patches[j*m_MapSizePatches+i].m_MiniPatches,sizeof(CMiniPatch)*PATCH_SIZE*PATCH_SIZE);
+            // Incrementing offsets in source need to be adjusted to 0-based, since the X/ZSource variables are the new "0"
+            CPatch& src = m_Patches[(upperLeftZSource + (j - upperLeftZ)) * m_MapSizePatches + upperLeftXSource + (i - upperLeftX)];
+            CPatch& dst = newPatches[j * size + i];
+            std::copy_n(&(src.m_MiniPatches[0][0]), PATCH_SIZE * PATCH_SIZE, &(dst.m_MiniPatches[0][0]));
+        }
+        for (ssize_t i = 0; i < upperLeftX; ++i)
+        {
+            for (ssize_t patch_j = 0; patch_j < PATCH_SIZE; ++patch_j) {
+                CMiniPatch& src = newPatches[j * size + upperLeftX].m_MiniPatches[patch_j][0];
+                for (ssize_t patch_i = 0; patch_i < PATCH_SIZE; ++patch_i) {
+                    CMiniPatch& dst = newPatches[j * size + i].m_MiniPatches[patch_j][patch_i];
+                    dst = src;
+                }
             }
         }
-
-        if (j<m_MapSizePatches && size>m_MapSizePatches) {
-            // copy over the last tile from each column
-            for (ssize_t n=0;n<size-m_MapSizePatches;n++) {
-                for (ssize_t m=0;m<PATCH_SIZE;m++) {
-                    CMiniPatch& src=m_Patches[j*m_MapSizePatches+m_MapSizePatches-1].m_MiniPatches[m][15];
-                    for (ssize_t k=0;k<PATCH_SIZE;k++) {
-                        CMiniPatch& dst=newPatches[j*size+m_MapSizePatches+n].m_MiniPatches[m][k];
-                        dst = src;
-                    }
+        for (ssize_t i = upperLeftX + width; i < size; ++i)
+        {
+            for (ssize_t patch_j = 0; patch_j < PATCH_SIZE; ++patch_j) {
+                CMiniPatch& src = newPatches[j * size + upperLeftX + width - 1].m_MiniPatches[patch_j][PATCH_SIZE - 1];
+                for (ssize_t patch_i = 0; patch_i < PATCH_SIZE; ++patch_i) {
+                    CMiniPatch& dst = newPatches[j * size + i].m_MiniPatches[patch_j][patch_i];
+                    dst = src;
                 }
             }
         }
     }
-
-    if (size>m_MapSizePatches) {
-        // copy over the last tile from each column
-        CPatch* srcpatch=&newPatches[(m_MapSizePatches-1)*size];
-        CPatch* dstpatch=srcpatch+size;
-        for (ssize_t p=0;p<(ssize_t)size-m_MapSizePatches;p++) {
-            for (ssize_t n=0;n<(ssize_t)size;n++) {
-                for (ssize_t m=0;m<PATCH_SIZE;m++) {
-                    for (ssize_t k=0;k<PATCH_SIZE;k++) {
-                        CMiniPatch& src=srcpatch->m_MiniPatches[15][k];
-                        CMiniPatch& dst=dstpatch->m_MiniPatches[m][k];
-                        dst = src;
-                    }
+    for (ssize_t j = 0; j < upperLeftZ; ++j) {
+        CPatch* srcpatch = newPatches + (upperLeftZ * size);
+        CPatch* dstpatch = newPatches + j * size;
+        for (ssize_t i = 0; i < size; ++i){
+            for (ssize_t patch_j = 0; patch_j < PATCH_SIZE; ++patch_j) {
+                for (ssize_t patch_i = 0; patch_i < PATCH_SIZE; ++patch_i) {
+                    CMiniPatch& src = srcpatch->m_MiniPatches[0][patch_i];
+                    CMiniPatch& dst = dstpatch->m_MiniPatches[patch_j][patch_i];
+                    dst = src;
                 }
-                srcpatch++;
-                dstpatch++;
             }
+            ++srcpatch;
+            ++dstpatch;
+        }
+    }
+    for (ssize_t j = upperLeftZ + height; j < size; ++j) {
+        CPatch* srcpatch = newPatches + ((upperLeftZ + height - 1) * size);
+        CPatch* dstpatch = newPatches + j * size;
+        for (ssize_t i = 0; i < size; ++i){
+            for (ssize_t patch_j = 0; patch_j < PATCH_SIZE; ++patch_j) {
+                for (ssize_t patch_i = 0; patch_i < PATCH_SIZE; ++patch_i) {
+                    CMiniPatch& src = srcpatch->m_MiniPatches[PATCH_SIZE - 1][patch_i];
+                    CMiniPatch& dst = dstpatch->m_MiniPatches[patch_j][patch_i];
+                    dst = src;
+                }
+            }
+            ++srcpatch;
+            ++dstpatch;
         }
     }
-
 
     // release all the original data
     ReleaseData();
 
     // store new data
-    m_Heightmap=newHeightmap;
-    m_Patches=newPatches;
-    m_MapSize=(ssize_t)newMapSize;
-    m_MapSizePatches=(ssize_t)size;
+    m_Heightmap = newHeightmap;
+    m_Patches = newPatches;
+    m_MapSize = (ssize_t)newMapSize;
+    m_MapSizePatches = (ssize_t)size;
 
     // initialise all the new patches
     InitialisePatches();
 
     // initialise mipmap
-    m_HeightMipmap.Initialize(m_MapSize,m_Heightmap);
+    m_HeightMipmap.Initialize(m_MapSize, m_Heightmap);
 }
 
 ///////////////////////////////////////////////////////////////////////////////

source/graphics/Terrain.h

@@ -98 +98 @@
     // should be in the direction (1,-1); false if it should be (1,1)
     bool GetTriangulationDir(ssize_t i, ssize_t j) const;
 
-    // resize this terrain such that each side has given number of patches
-    void Resize(ssize_t size);
+    // resize this terrain such that each side has given number of patches,
+    // with the center offset in patches from the larger of the two sizes.
+    void ResizeRecenter(ssize_t size, int horizontalOffset = 0, int verticalOffset = 0);
 
     // set up a new heightmap from 16 bit data; assumes heightmap matches current terrain size
     void SetHeightMap(u16* heightmap);

source/tools/atlas/AtlasUI/CustomControls/MapResizeDialog/MapResizeDialog.cpp

@@ -24 +24 @@
 #include "GameInterface/Messages.h"
 
 #include <wx/statline.h>
-#include "PsuedoMiniMapPanel.h"
 
 MapResizeDialog::MapResizeDialog(wxWindow* parent)
-    : wxDialog(parent, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxCAPTION | wxRESIZE_BORDER),
-    m_NewSize(0)
+    : wxDialog(parent, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxCAPTION | wxRESIZE_BORDER)
 {
     Freeze();
 
     AtlasMessage::qGetCurrentMapSize qrySize;
     qrySize.Post();
-    int currentSize = qrySize.size;
+    m_NewSize = qrySize.size;
 
     SetTitle(_("Resize map"));
     wxSizer* sizer = new wxBoxSizer(wxVERTICAL);
@@ -52 +50 @@
     {   
         wxString size(s["Tiles"]);
         listBox->Append(wxString(s["Name"]), new wxStringClientData(size));
-        if (currentSize == wxAtoi(size))
+        if (m_NewSize == wxAtoi(size))
             listBox->SetSelection(listBox->GetCount() - 1);
     }
     listAndMap->Add(listBox, wxSizerFlags().Align(wxALIGN_LEFT).Proportion(1).Expand());
     listAndMap->AddSpacer(10);
 
-    PsuedoMiniMapPanel* miniMap = new PsuedoMiniMapPanel(this, currentSize);
-    listBox->Bind(wxEVT_LISTBOX, &PsuedoMiniMapPanel::OnNewSize, miniMap);
+    m_MiniMap = new PsuedoMiniMapPanel(this, m_NewSize);
+    listBox->Bind(wxEVT_LISTBOX, &PsuedoMiniMapPanel::OnNewSize, m_MiniMap);
 
-    listAndMap->Add(miniMap, wxSizerFlags());
+    listAndMap->Add(m_MiniMap, wxSizerFlags());
     sizer->Add(listAndMap, wxSizerFlags().Proportion(1).Expand().Border(wxLEFT | wxRIGHT, 10));
 
     sizer->AddSpacer(5);
@@ -85 +83 @@
     return m_NewSize;
 }
 
+wxPoint MapResizeDialog::GetOffset() const
+{
+    return m_MiniMap->GetOffset();
+}
+
 void MapResizeDialog::OnListBox(wxCommandEvent& evt)
 {
     if (!evt.IsSelection())
         return;
 
     m_NewSize = wxAtoi(static_cast<wxStringClientData*>(evt.GetClientObject())->GetData());
-    
     if (evt.GetEventType() == wxEVT_COMMAND_LISTBOX_DOUBLECLICKED)
     {
         EndModal(wxID_OK);

source/tools/atlas/AtlasUI/CustomControls/MapResizeDialog/MapResizeDialog.h

@@ -19 +19 @@
 #define INCLUDED_MAPRESIZEDIALOG
 
 #include <wx/dialog.h>
+#include "PsuedoMiniMapPanel.h"
 
 class MapResizeDialog : public wxDialog
 {
@@ -29 +30 @@
      * Returns selected new size.
      */
     size_t GetNewSize() const;
+    /**
+     * Returns the offset from center.
+     */
+    wxPoint GetOffset() const;
 
 private:
     void OnCancel(wxCommandEvent& evt);
@@ -36 +41 @@
     void OnListBox(wxCommandEvent& evt);
 
     size_t m_NewSize;
+    PsuedoMiniMapPanel* m_MiniMap;
 
     DECLARE_EVENT_TABLE();
 };

source/tools/atlas/AtlasUI/CustomControls/MapResizeDialog/PsuedoMiniMapPanel.cpp

@@ -66 +66 @@
     : wxPanel(parent, wxID_ANY, wxDefaultPosition, wxSize(PanelRadius * 2 + 1, PanelRadius * 2 + 1)),
     m_CurrentSize(currentSize), m_ScreenTones(),
     m_LastMousePos(-1, -1), m_Dragging(false),
-    m_SelectionRadius(PanelRadius), m_SelectionCenter(PanelCenter), m_SameOrGrowing(true)
+    m_SelectionRadius(PanelRadius), m_SelectionCenter(PanelCenter), m_SameOrGrowing(true), m_NewSize(currentSize)
 {
 
     AtlasMessage::qGetMiniMapDisplay qryBackground;
@@ -81 +81 @@
     SetBackgroundStyle(wxBG_STYLE_PAINT);
 }
 
+wxPoint PsuedoMiniMapPanel::GetOffset() const 
+{
+    // Since offset is from center, amplitude is (at most) half the largest size.
+    int size = std::max(m_CurrentSize, m_NewSize) / 2;
+    // If the map is growing, the display is opposite what the actual offset is.
+    float scalar = (m_SameOrGrowing ? 1.0 : -1.0) / PanelRadius * size;
+    // Rebase offsets to center.
+    int hOffset = m_SelectionCenter.x - PanelCenter.x;
+    int vOffset = m_SelectionCenter.y - PanelCenter.y;
+    return wxPoint(scalar * hOffset, scalar * vOffset);
+}
+
 void PsuedoMiniMapPanel::OnNewSize(wxCommandEvent& evt)
 {
     if (!evt.IsSelection())
         return;
 
-    int newSize = wxAtoi(static_cast<wxStringClientData*>(evt.GetClientObject())->GetData());
+    evt.Skip();
 
-    m_SameOrGrowing = newSize >= m_CurrentSize;
-    m_SelectionRadius = double(std::min(newSize, m_CurrentSize)) / std::max(newSize, m_CurrentSize) * PanelRadius;
+    m_NewSize = wxAtoi(static_cast<wxStringClientData*>(evt.GetClientObject())->GetData());
 
+    m_SameOrGrowing = m_NewSize >= m_CurrentSize;
+    m_SelectionRadius = double(std::min(m_NewSize, m_CurrentSize)) / std::max(m_NewSize, m_CurrentSize) * PanelRadius;
     if (!m_SameOrGrowing && m_ScreenTones.find(m_SelectionRadius) == m_ScreenTones.cend())
     {
         wxImage overlay = wxImage(PanelRadius * 4, PanelRadius * 4);
@@ -177 +190 @@
 
         const wxPen BorderPen(*wxWHITE, 2);
         dc.SetPen(BorderPen);
-        dc.DrawCircle(m_SelectionCenter, m_SelectionRadius);
-        
+        dc.DrawCircle(m_SelectionCenter, m_SelectionRadius);        
     }
     else
     {
@@ -210 +222 @@
 }
 
 BEGIN_EVENT_TABLE(PsuedoMiniMapPanel, wxPanel)
+EVT_LEAVE_WINDOW(PsuedoMiniMapPanel::OnMouseUp)
 EVT_LEFT_DOWN(PsuedoMiniMapPanel::OnMouseDown)
 EVT_LEFT_UP(PsuedoMiniMapPanel::OnMouseUp)
 EVT_RIGHT_DOWN(PsuedoMiniMapPanel::OnMouseDown)

source/tools/atlas/AtlasUI/CustomControls/MapResizeDialog/PsuedoMiniMapPanel.h

@@ -15 +15 @@
 * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+
+#ifndef INCLUDED_PSUEDOMINIMAPPANEL
+#define INCLUDED_PSUEDOMINIMAPPANEL
+
 #include <wx/panel.h>
 
 class PsuedoMiniMapPanel : public wxPanel
@@ -26 +30 @@
     void EraseBackground(wxEraseEvent& evt);
 
     void OnNewSize(wxCommandEvent& evt);
+
+    wxPoint GetOffset() const;
 private:
     void OnMouseDown(wxMouseEvent& evt);
     void OnMouseUp(wxMouseEvent& evt);
@@ -38 +44 @@
 
     wxPoint m_LastMousePos;
     bool m_Dragging;
-
     wxPoint m_SelectionCenter;
     int m_SelectionRadius;
     bool m_SameOrGrowing;
+    int m_NewSize;
 
     DECLARE_EVENT_TABLE();
 };
+
+#endif // INCLUDED_PSUEDOMINIMAPPANEL
+ No newline at end of file

source/tools/atlas/AtlasUI/ScenarioEditor/Sections/Terrain/Terrain.cpp

@@ -284 +284 @@
 
     if (dlg.ShowModal() != wxID_OK)
         return;
-    
-    POST_COMMAND(ResizeMap, (dlg.GetNewSize()));
+    wxPoint offset = dlg.GetOffset();
+    POST_COMMAND(ResizeMap, (dlg.GetNewSize(), offset.x, offset.y));
 }
 
 BEGIN_EVENT_TABLE(TerrainSidebar, Sidebar)

source/tools/atlas/GameInterface/Handlers/MapHandlers.cpp

@@ -218 +218 @@
 
     // resize terrain to heightmap size
     CTerrain* terrain = g_Game->GetWorld()->GetTerrain();
-    terrain->Resize(terrainSize / PATCH_SIZE);
+    terrain->ResizeRecenter(terrainSize / PATCH_SIZE);
 
     // copy heightmap data into map
     u16* heightmap = g_Game->GetWorld()->GetTerrain()->GetHeightMap();
@@ -403 +403 @@
 BEGIN_COMMAND(ResizeMap)
 {
     int m_OldTiles, m_NewTiles;
+    int m_OffsetX, m_OffsetY;
 
     cResizeMap()
     {
@@ -419 +420 @@
         g_Game->GetView()->GetLOSTexture().MakeDirty();
     }
 
-    void ResizeTerrain(int tiles)
+    void ResizeTerrain(int tiles, int offsetX, int offsetY)
     {
         CTerrain* terrain = g_Game->GetWorld()->GetTerrain();
 
-        terrain->Resize(tiles / PATCH_SIZE);
+        // Need to flip offset of vertical offset, due to screen mapping order.
+        terrain->ResizeRecenter(tiles / PATCH_SIZE, offsetX / PATCH_SIZE, -offsetY / PATCH_SIZE);
 
         MakeDirty();
     }
@@ -434 +436 @@
         if (!cmpTerrain)
         {
             m_OldTiles = m_NewTiles = 0;
+            m_OffsetX = m_OffsetY = 0;
         }
         else
         {
             m_OldTiles = (int)cmpTerrain->GetTilesPerSide();
             m_NewTiles = msg->tiles;
+            m_OffsetX = msg->offsetX;
+            m_OffsetY = msg->offsetY;
         }
 
-        ResizeTerrain(m_NewTiles);
+        ResizeTerrain(m_NewTiles, m_OffsetX, m_OffsetY);
     }
 
     void Undo()
     {
-        ResizeTerrain(m_OldTiles);
+        ResizeTerrain(m_OldTiles, -m_OffsetX, -m_OffsetY);
     }
 
     void Redo()
     {
-        ResizeTerrain(m_NewTiles);
+        ResizeTerrain(m_NewTiles, m_OffsetX, m_OffsetY);
     }
 };
 END_COMMAND(ResizeMap)

source/tools/atlas/GameInterface/Messages.h

@@ -211 +211 @@
 
 COMMAND(ResizeMap, NOMERGE,
         ((int, tiles))
+        ((int, offsetX))
+        ((int, offsetY))
         );
 
 QUERY(VFSFileExists,

source/tools/atlas/AtlasUI/CustomControls/MapResizeDialog/PsuedoMiniMapPanel.cpp

@@ -20 +20 @@
 #include "PsuedoMiniMapPanel.h"
 
 #include "GameInterface/Messages.h"
+#include "GameInterface/MessagePasser.h"
 #include "ScenarioEditor/Tools/Common/Tools.h"
 
 #include <math.h>
@@ -29 +30 @@
 
 namespace
 {
-    const int PanelRadius = 75;
+    const int PanelRadius = 64 + 1;
     const wxPoint PanelCenter = wxPoint(PanelRadius + 1, PanelRadius + 1);
     const char* ScreenToneMask[] =
     {
@@ -45 +46 @@
     };
     const wxPoint ScreenToneOffset(-2 * PanelRadius, -2 * PanelRadius);
     const wxPen Rim(*wxBLACK, 3);
+    const wxPen BackgroundMask(*wxBLACK, 2 * PanelRadius);
 
     bool Within(const wxPoint& test, const wxPoint& center, int radius)
     {
@@ -66 +68 @@
     m_LastMousePos(-1, -1), m_Dragging(false),
     m_SelectionRadius(PanelRadius), m_SelectionCenter(PanelCenter), m_SameOrGrowing(true)
 {
+
+    AtlasMessage::qGetMiniMapDisplay qryBackground;
+    qryBackground.Post();
+    int dim = qryBackground.dimension;
+    unsigned char* data = static_cast<unsigned char*>((void*)qryBackground.imageBytes);
+    
+    m_Background = wxImage(dim, dim, data);
+    m_Background.Rescale(PanelRadius * 2, PanelRadius * 2, wxIMAGE_QUALITY_BOX_AVERAGE);
+    m_Backgrounds[PanelRadius] = wxBitmap(m_Background);
+
     SetBackgroundStyle(wxBG_STYLE_PAINT);
 }
 
@@ -96 +108 @@
         overlay.ConvertColourToAlpha(0, 0, 0);
 
         m_ScreenTones[m_SelectionRadius] = wxBitmap(overlay);
+    } 
+    else if (m_SameOrGrowing && m_Backgrounds.find(m_SelectionRadius) == m_Backgrounds.cend())
+    {
+        wxImage rescaled = wxImage(m_Background);
+        rescaled.Rescale(2 * m_SelectionRadius, 2 * m_SelectionRadius, wxIMAGE_QUALITY_BOX_AVERAGE);
+        m_Backgrounds[m_SelectionRadius] = wxBitmap(rescaled);
     }
 
     Refresh();
@@ -151 +169 @@
     wxGCDC dc(dca);
     if (m_SameOrGrowing)
     {
-        dc.SetBrush(*wxBLACK_BRUSH);
-        dc.DrawRectangle(0, 0, 2 * PanelRadius, 2 * PanelRadius);
-        dc.SetBrush(*wxWHITE_BRUSH);
-        dc.DrawCircle(m_SelectionCenter, m_SelectionRadius + 1);
-        dc.SetBrush(*wxGREEN_BRUSH);
+        dc.DrawBitmap(m_Backgrounds[m_SelectionRadius], m_SelectionCenter - wxSize(m_SelectionRadius, m_SelectionRadius));
+        
+        dc.SetBrush(*wxTRANSPARENT_BRUSH);
+        dc.SetPen(BackgroundMask);
+        dc.DrawCircle(m_SelectionCenter, PanelRadius + m_SelectionRadius);
+
+        const wxPen BorderPen(*wxWHITE, 2);
+        dc.SetPen(BorderPen);
         dc.DrawCircle(m_SelectionCenter, m_SelectionRadius);
+        
     }
     else
     {
-        dc.SetBrush(*wxGREEN_BRUSH);
-        dc.DrawRectangle(0, 0, 2 * PanelRadius, 2 * PanelRadius);
-        
+        dc.DrawBitmap(m_Backgrounds[PanelRadius], 0, 0);        
         // "fade out" trimmed areas by drawing a screentone ring ring.
         dc.DrawBitmap(m_ScreenTones[m_SelectionRadius], ScreenToneOffset + m_SelectionCenter);
     }
 
     // Centering markers.
     dc.SetBrush(*wxBLACK_BRUSH);
-    dc.DrawCircle(m_SelectionCenter, 3);
+    dc.SetPen(*wxBLACK_PEN);
+    dc.DrawCircle(m_SelectionCenter, 2);
     dc.SetPen(*wxWHITE_PEN);
     dc.DrawLine(PanelRadius - 10, PanelRadius, PanelRadius + 10, PanelRadius);
     dc.DrawLine(PanelRadius, PanelRadius + 10, PanelRadius, PanelRadius - 10);
@@ -197 +218 @@
 EVT_MIDDLE_UP(PsuedoMiniMapPanel::OnMouseUp)
 EVT_MOTION(PsuedoMiniMapPanel::OnMouseMove)
 EVT_PAINT(PsuedoMiniMapPanel::PaintEvent)
-EVT_ERASE_BACKGROUND(PsuedoMiniMapPanel::EraseBackground)
 END_EVENT_TABLE()
- No newline at end of file

source/tools/atlas/AtlasUI/CustomControls/MapResizeDialog/PsuedoMiniMapPanel.h

@@ -32 +32 @@
     void OnMouseMove(wxMouseEvent& evt);
 
     const int m_CurrentSize;
+    wxImage m_Background;
     std::map<int, wxBitmap> m_ScreenTones;
+    std::map<int, wxBitmap> m_Backgrounds;
 
     wxPoint m_LastMousePos;
     bool m_Dragging;

source/tools/atlas/GameInterface/Handlers/MapHandlers.cpp

@@ -35 +35 @@
 #include "ps/CLogger.h"
 #include "ps/Filesystem.h"
 #include "ps/Game.h"
+#include "ps/GameSetup/GameSetup.h"
 #include "ps/Loader.h"
 #include "ps/World.h"
 #include "renderer/Renderer.h"
+#include "renderer/WaterManager.h"
 #include "scriptinterface/ScriptInterface.h"
 #include "simulation2/Simulation2.h"
 #include "simulation2/components/ICmpPlayer.h"
@@ -45 +47 @@
 #include "simulation2/components/ICmpPosition.h"
 #include "simulation2/components/ICmpRangeManager.h"
 #include "simulation2/components/ICmpTerrain.h"
+#include "simulation2/system/ParamNode.h"
 
 namespace
 {
@@ -307 +310 @@
     msg->sizes = g_Game->GetSimulation2()->GetMapSizes();
 }
 
+QUERYHANDLER(GetMiniMapDisplay)
+{
+    const CTerrain* terrain = g_Game->GetWorld()->GetTerrain();
+    const ssize_t dimension = terrain->GetVerticesPerSide() - 1;
+    const ssize_t bpp = 24;
+    const ssize_t buf_size = dimension * dimension * (bpp / 8);
+
+    // Data is destined for a wxImage, which uses free.
+    unsigned char* img = static_cast<unsigned char*>(malloc(buf_size));
+    if (img)
+    {
+        // Stolen from MiniMap.cpp
+        float shallowPassageHeight = 0.0f;
+        // Get the maximum height for unit passage in water.
+        CParamNode externalParamNode;
+        CParamNode::LoadXML(externalParamNode, L"simulation/data/pathfinder.xml", "pathfinder");
+        const CParamNode pathingSettings = externalParamNode.GetChild("Pathfinder").GetChild("PassabilityClasses");
+        if (pathingSettings.GetChild("default").IsOk() && pathingSettings.GetChild("default").GetChild("MaxWaterDepth").IsOk())
+            shallowPassageHeight = pathingSettings.GetChild("default").GetChild("MaxWaterDepth").ToFloat();
+
+        ssize_t w = dimension;
+        ssize_t h = dimension;
+        float waterHeight = g_Renderer.GetWaterManager()->m_WaterHeight;
+
+        for (ssize_t j = 0; j < h; ++j)
+        {
+            // Work backwards to vertically flip the image.
+            unsigned char* dataPtr = img + 3 * (h - j - 1) * dimension;
+            for (ssize_t i = 0; i < w; ++i)
+            {
+                float avgHeight = (terrain->GetVertexGroundLevel(i, j)
+                    + terrain->GetVertexGroundLevel(i + 1, j)
+                    + terrain->GetVertexGroundLevel(i, j + 1)
+                    + terrain->GetVertexGroundLevel(i + 1, j + 1)
+                    ) / 4.0f;
+
+                if (avgHeight < waterHeight && avgHeight > waterHeight - shallowPassageHeight)
+                {
+                    // shallow water
+                    *dataPtr++ = 0x70;
+                    *dataPtr++ = 0x98;
+                    *dataPtr++ = 0xc0;
+                }
+                else if (avgHeight < waterHeight)
+                {
+                    // Set water as constant color for consistency on different maps
+                    *dataPtr++ = 0x50;
+                    *dataPtr++ = 0x78;
+                    *dataPtr++ = 0xa0;
+                }
+                else
+                {
+                    int hmap = ((int)terrain->GetHeightMap()[j * dimension + i]) >> 8;
+                    float scale = float((hmap / 3) + 170) / 255.0f;
+
+                    u32 color = 0xFFFFFFFF;
+
+                    CMiniPatch* mp = terrain->GetTile(i, j);
+                    if (mp)
+                    {
+                        CTerrainTextureEntry* tex = mp->GetTextureEntry();
+                        if (tex)
+                        {
+                            color = tex->GetBaseColor();
+                        }
+                    }
+
+                    // Convert 
+                    *dataPtr++ = unsigned char(float(color & 0xff) * scale);
+                    *dataPtr++ = unsigned char(float((color >> 8) & 0xff) * scale);
+                    *dataPtr++ = unsigned char(float((color >> 16) & 0xff) * scale);
+                }
+            }
+        }
+    }
+        
+    msg->imageBytes = static_cast<void*>(img);
+    msg->dimension = dimension;
+}
+
 QUERYHANDLER(GetRMSData)
 {
     msg->data = g_Game->GetSimulation2()->GetRMSData();

source/tools/atlas/GameInterface/Messages.h

@@ -198 +198 @@
         ((int, size))
         );
 
+QUERY(GetMiniMapDisplay,
+        ,
+        ((int, dimension))
+        ((void*, imageBytes))
+        );
+
 QUERY(GetRMSData,
         ,
         ((std::vector<std::string>, data))

source/tools/atlas/AtlasUI/CustomControls/MapResizeDialog/MapResizeDialog.cpp

@@ -24 +24 @@
 #include "GameInterface/Messages.h"
 
 #include <wx/statline.h>
+#include "PsuedoMiniMapPanel.h"
 
-MapResizeDialog::MapResizeDialog(wxWindow* parent, size_t currentSize)
-    : wxDialog(parent, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize(600, 400), wxCAPTION | wxRESIZE_BORDER),
+MapResizeDialog::MapResizeDialog(wxWindow* parent)
+    : wxDialog(parent, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxCAPTION | wxRESIZE_BORDER),
     m_NewSize(0)
 {
     Freeze();
 
+    AtlasMessage::qGetCurrentMapSize qrySize;
+    qrySize.Post();
+    int currentSize = qrySize.size;
+
+    SetTitle(_("Resize map"));
+    wxSizer* sizer = new wxBoxSizer(wxVERTICAL);
+    wxStaticText* label = new wxStaticText(this, wxID_ANY, _("Select new map size. WARNING: This probably only works reliably on blank maps."), wxDefaultPosition, wxDefaultSize);
+    sizer->Add(label, wxSizerFlags().Align(wxALIGN_CENTER_HORIZONTAL).Border(wxALL, 10));
+
+    wxBoxSizer* listAndMap = new wxBoxSizer(wxHORIZONTAL);
+    
+    wxListBox* listBox = new wxListBox(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, 0, NULL, wxLB_SINGLE | wxLB_HSCROLL);
     // Load the map sizes list
     AtlasMessage::qGetMapSizes qrySizes;
     qrySizes.Post();
     AtObj sizes = AtlasObject::LoadFromJSON(*qrySizes.sizes);
     for (AtIter s = sizes["Data"]["item"]; s.defined(); ++s)
-    {
-        long tiles = 0;
-        wxString(s["Tiles"]).ToLong(&tiles);
-        m_SizeNames.Add(wxString(s["Name"]));
-        m_SizeTiles.push_back((size_t)tiles);
+    {   
+        wxString size(s["Tiles"]);
+        listBox->Append(wxString(s["Name"]), new wxStringClientData(size));
+        if (currentSize == wxAtoi(size))
+            listBox->SetSelection(listBox->GetCount() - 1);
     }
+    listAndMap->Add(listBox, wxSizerFlags().Align(wxALIGN_LEFT).Proportion(1).Expand());
+    listAndMap->AddSpacer(10);
 
-    SetTitle(_("Resize map"));
-
-    wxSizer* sizer = new wxBoxSizer(wxVERTICAL);
-
-    wxStaticText* label = new wxStaticText(this, wxID_ANY, _("Select new map size. WARNING: This probably only works reliably on blank maps."), wxDefaultPosition, wxDefaultSize);
-    sizer->Add(label, wxSizerFlags().Align(wxALIGN_CENTER).Border(wxALL, 10));
-    
-    wxListBox* listBox = new wxListBox(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, 0, NULL, wxLB_SINGLE | wxLB_HSCROLL);
-    listBox->Append(m_SizeNames);
+    PsuedoMiniMapPanel* miniMap = new PsuedoMiniMapPanel(this, currentSize);
+    listBox->Bind(wxEVT_LISTBOX, &PsuedoMiniMapPanel::OnNewSize, miniMap);
 
+    listAndMap->Add(miniMap, wxSizerFlags());
+    sizer->Add(listAndMap, wxSizerFlags().Proportion(1).Expand().Border(wxLEFT | wxRIGHT, 10));
 
+    sizer->AddSpacer(5);
     sizer->Add(new wxStaticLine(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL), wxSizerFlags().Expand().Border(wxRIGHT | wxLEFT, 7));
     sizer->AddSpacer(5);
 
@@ -76 +87 @@
 
 void MapResizeDialog::OnListBox(wxCommandEvent& evt)
 {
-    int index = evt.GetInt();
-    if (index < 0 || index >= m_SizeTiles.size())
+    if (!evt.IsSelection())
         return;
 
-    m_NewSize = m_SizeTiles[index];
+    m_NewSize = wxAtoi(static_cast<wxStringClientData*>(evt.GetClientObject())->GetData());
     
     if (evt.GetEventType() == wxEVT_COMMAND_LISTBOX_DOUBLECLICKED)
     {

source/tools/atlas/AtlasUI/CustomControls/MapResizeDialog/MapResizeDialog.h

@@ -23 +23 @@
 class MapResizeDialog : public wxDialog
 {
 public:
-    MapResizeDialog(wxWindow* parent, size_t currentSize);
+    MapResizeDialog(wxWindow* parent);
 
     /**
      * Returns selected new size.
@@ -36 +36 @@
     void OnListBox(wxCommandEvent& evt);
 
     size_t m_NewSize;
-    wxArrayString m_SizeNames;
-    std::vector<size_t> m_SizeTiles;
 
     DECLARE_EVENT_TABLE();
 };

new file source/tools/atlas/AtlasUI/CustomControls/MapResizeDialog/PsuedoMiniMapPanel.cpp

@@ +1 @@
+/* Copyright (C) 2016 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 "PsuedoMiniMapPanel.h"
+
+#include "GameInterface/Messages.h"
+#include "ScenarioEditor/Tools/Common/Tools.h"
+
+#include <math.h>
+#include <wx/dcbuffer.h>
+#include <wx/dcgraph.h>
+#include <wx/defs.h> 
+
+namespace
+{
+    const int PanelRadius = 75;
+    const wxPoint PanelCenter = wxPoint(PanelRadius + 1, PanelRadius + 1);
+    const char* ScreenToneMask[] =
+    {
+        /* columns rows colors chars-per-pixel */
+        "4 4 2 1",
+        "X c White",
+        "O c Black",
+        /* pixels */
+        "OOOO",
+        "OXXO",
+        "OXXO",
+        "OOOO"
+    };
+    const wxPoint ScreenToneOffset(-2 * PanelRadius, -2 * PanelRadius);
+    const wxPen Rim(*wxBLACK, 3);
+
+    bool Within(const wxPoint& test, const wxPoint& center, int radius)
+    {
+        int dx = abs(test.x - center.x);
+        if (dx > radius)
+            return false;
+        int dy = abs(test.y - center.y);
+        if (dy > radius)
+            return false;
+        if (dx + dy <= radius)
+            return true;
+        return (dx * dx + dy * dy <= radius * radius);
+    }
+}
+
+PsuedoMiniMapPanel::PsuedoMiniMapPanel(wxWindow* parent, int currentSize)
+    : wxPanel(parent, wxID_ANY, wxDefaultPosition, wxSize(PanelRadius * 2 + 1, PanelRadius * 2 + 1)),
+    m_CurrentSize(currentSize), m_ScreenTones(),
+    m_LastMousePos(-1, -1), m_Dragging(false),
+    m_SelectionRadius(PanelRadius), m_SelectionCenter(PanelCenter), m_SameOrGrowing(true)
+{
+    SetBackgroundStyle(wxBG_STYLE_PAINT);
+}
+
+void PsuedoMiniMapPanel::OnNewSize(wxCommandEvent& evt)
+{
+    if (!evt.IsSelection())
+        return;
+
+    int newSize = wxAtoi(static_cast<wxStringClientData*>(evt.GetClientObject())->GetData());
+
+    m_SameOrGrowing = newSize >= m_CurrentSize;
+    m_SelectionRadius = double(std::min(newSize, m_CurrentSize)) / std::max(newSize, m_CurrentSize) * PanelRadius;
+
+    if (!m_SameOrGrowing && m_ScreenTones.find(m_SelectionRadius) == m_ScreenTones.cend())
+    {
+        wxImage overlay = wxImage(PanelRadius * 4, PanelRadius * 4);
+        overlay.InitAlpha();
+        wxGraphicsContext* gc = wxGraphicsContext::Create(overlay);
+        gc->SetBrush(wxBrush(ScreenToneMask));
+        gc->DrawRectangle(0, 0, PanelRadius * 4, PanelRadius * 4);
+        gc->SetBrush(*wxBLACK_BRUSH);
+        gc->DrawEllipse(PanelRadius * 2 - m_SelectionRadius, PanelRadius * 2  - m_SelectionRadius, m_SelectionRadius * 2, m_SelectionRadius * 2);
+        gc->SetPen(*wxWHITE_PEN);
+        gc->DrawEllipse(PanelRadius * 2 - m_SelectionRadius, PanelRadius * 2 - m_SelectionRadius, m_SelectionRadius * 2, m_SelectionRadius * 2);
+        delete gc;
+        // Black -> Converted to transparent.
+        // White -> converted to black.
+        overlay.ConvertColourToAlpha(0, 0, 0);
+
+        m_ScreenTones[m_SelectionRadius] = wxBitmap(overlay);
+    }
+
+    Refresh();
+}
+
+void PsuedoMiniMapPanel::OnMouseDown(wxMouseEvent& evt)
+{
+    // Capture on button-down, so we can respond even when the mouse
+    // moves off the window
+    if (!m_Dragging && evt.ButtonDown() &&
+        Within(evt.GetPosition(), PanelCenter, PanelRadius) &&
+        Within(evt.GetPosition(), m_SelectionCenter, m_SelectionRadius))
+    {
+        m_LastMousePos = evt.GetPosition();
+        m_Dragging = true;
+    }
+}
+
+void PsuedoMiniMapPanel::OnMouseUp(wxMouseEvent& evt)
+{
+    if (m_Dragging &&
+        !(evt.ButtonIsDown(wxMOUSE_BTN_LEFT) || evt.ButtonIsDown(wxMOUSE_BTN_MIDDLE) || evt.ButtonIsDown(wxMOUSE_BTN_RIGHT))
+        )
+    {
+        m_Dragging = false;
+    }
+}
+
+void PsuedoMiniMapPanel::OnMouseMove(wxMouseEvent& evt)
+{
+    if (m_Dragging && evt.Dragging())
+    {
+        if (m_LastMousePos == evt.GetPosition())
+            return;
+
+        wxPoint delta = evt.GetPosition() - m_LastMousePos;
+        wxPoint moved = m_SelectionCenter + delta;
+
+        if (!Within(moved, PanelCenter, PanelRadius))
+            return;
+
+        m_SelectionCenter = moved;
+        m_LastMousePos = evt.GetPosition();
+        Refresh();
+    }
+}
+
+void PsuedoMiniMapPanel::PaintEvent(wxPaintEvent& WXUNUSED(evt))
+{
+    wxAutoBufferedPaintDC dca(this);
+    // Background must be grabbed from paint dc, not gc, or color may be transparent.
+    wxColor background = dca.GetBackground().GetColour();
+    wxGCDC dc(dca);
+    if (m_SameOrGrowing)
+    {
+        dc.SetBrush(*wxBLACK_BRUSH);
+        dc.DrawRectangle(0, 0, 2 * PanelRadius, 2 * PanelRadius);
+        dc.SetBrush(*wxWHITE_BRUSH);
+        dc.DrawCircle(m_SelectionCenter, m_SelectionRadius + 1);
+        dc.SetBrush(*wxGREEN_BRUSH);
+        dc.DrawCircle(m_SelectionCenter, m_SelectionRadius);
+    }
+    else
+    {
+        dc.SetBrush(*wxGREEN_BRUSH);
+        dc.DrawRectangle(0, 0, 2 * PanelRadius, 2 * PanelRadius);
+        
+        // "fade out" trimmed areas by drawing a screentone ring ring.
+        dc.DrawBitmap(m_ScreenTones[m_SelectionRadius], ScreenToneOffset + m_SelectionCenter);
+    }
+
+    // Centering markers.
+    dc.SetBrush(*wxBLACK_BRUSH);
+    dc.DrawCircle(m_SelectionCenter, 3);
+    dc.SetPen(*wxWHITE_PEN);
+    dc.DrawLine(PanelRadius - 10, PanelRadius, PanelRadius + 10, PanelRadius);
+    dc.DrawLine(PanelRadius, PanelRadius + 10, PanelRadius, PanelRadius - 10);
+
+    // Round border.
+    dc.SetBrush(*wxTRANSPARENT_BRUSH);
+    dc.SetPen(Rim);
+    dc.DrawCircle(PanelCenter, PanelRadius - 1);
+    wxPen mask(background, PanelRadius);
+    dc.SetPen(mask);
+    dc.DrawCircle(PanelCenter, PanelRadius + PanelRadius / 2 - 1);
+}
+
+void PsuedoMiniMapPanel::EraseBackground(wxEraseEvent& WXUNUSED(evt))
+{
+    // Do nothing - don't erase to remove flicker.
+}
+
+BEGIN_EVENT_TABLE(PsuedoMiniMapPanel, wxPanel)
+EVT_LEFT_DOWN(PsuedoMiniMapPanel::OnMouseDown)
+EVT_LEFT_UP(PsuedoMiniMapPanel::OnMouseUp)
+EVT_RIGHT_DOWN(PsuedoMiniMapPanel::OnMouseDown)
+EVT_RIGHT_UP(PsuedoMiniMapPanel::OnMouseUp)
+EVT_MIDDLE_DOWN(PsuedoMiniMapPanel::OnMouseDown)
+EVT_MIDDLE_UP(PsuedoMiniMapPanel::OnMouseUp)
+EVT_MOTION(PsuedoMiniMapPanel::OnMouseMove)
+EVT_PAINT(PsuedoMiniMapPanel::PaintEvent)
+EVT_ERASE_BACKGROUND(PsuedoMiniMapPanel::EraseBackground)
+END_EVENT_TABLE()
+ No newline at end of file

new file source/tools/atlas/AtlasUI/CustomControls/MapResizeDialog/PsuedoMiniMapPanel.h

@@ +1 @@
+/* Copyright (C) 2016 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 <wx/panel.h>
+
+class PsuedoMiniMapPanel : public wxPanel
+{
+public:
+    PsuedoMiniMapPanel(wxWindow* parent, int currentSize);
+
+    void PaintEvent(wxPaintEvent& evt);
+    void EraseBackground(wxEraseEvent& evt);
+
+    void OnNewSize(wxCommandEvent& evt);
+private:
+    void OnMouseDown(wxMouseEvent& evt);
+    void OnMouseUp(wxMouseEvent& evt);
+    void OnMouseMove(wxMouseEvent& evt);
+
+    const int m_CurrentSize;
+    std::map<int, wxBitmap> m_ScreenTones;
+
+    wxPoint m_LastMousePos;
+    bool m_Dragging;
+
+    wxPoint m_SelectionCenter;
+    int m_SelectionRadius;
+    bool m_SameOrGrowing;
+
+    DECLARE_EVENT_TABLE();
+};

source/tools/atlas/AtlasUI/ScenarioEditor/Sections/Terrain/Terrain.cpp

@@ -280 +280 @@
 
 void TerrainSidebar::OnResizeMap(wxCommandEvent& WXUNUSED(evt))
 {
-
-    AtlasMessage::qGetCurrentMapSize qrySize;
-    qrySize.Post();
-
-    MapResizeDialog dlg(this, qrySize.size);
+    MapResizeDialog dlg(this);
 
     if (dlg.ShowModal() != wxID_OK)
         return;

new file source/tools/atlas/AtlasUI/CustomControls/MapResizeDialog/MapResizeDialog.cpp

@@ +1 @@
+/* Copyright (C) 2016 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 "MapResizeDialog.h"
+#include "ScenarioEditor/ScenarioEditor.h"
+
+#include "GameInterface/MessagePasser.h"
+#include "GameInterface/Messages.h"
+
+#include <wx/statline.h>
+
+MapResizeDialog::MapResizeDialog(wxWindow* parent, size_t currentSize)
+    : wxDialog(parent, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize(600, 400), wxCAPTION | wxRESIZE_BORDER),
+    m_NewSize(0)
+{
+    Freeze();
+
+    // Load the map sizes list
+    AtlasMessage::qGetMapSizes qrySizes;
+    qrySizes.Post();
+    AtObj sizes = AtlasObject::LoadFromJSON(*qrySizes.sizes);
+    for (AtIter s = sizes["Data"]["item"]; s.defined(); ++s)
+    {
+        long tiles = 0;
+        wxString(s["Tiles"]).ToLong(&tiles);
+        m_SizeNames.Add(wxString(s["Name"]));
+        m_SizeTiles.push_back((size_t)tiles);
+    }
+
+    SetTitle(_("Resize map"));
+
+    wxSizer* sizer = new wxBoxSizer(wxVERTICAL);
+
+    wxStaticText* label = new wxStaticText(this, wxID_ANY, _("Select new map size. WARNING: This probably only works reliably on blank maps."), wxDefaultPosition, wxDefaultSize);
+    sizer->Add(label, wxSizerFlags().Align(wxALIGN_CENTER).Border(wxALL, 10));
+    
+    wxListBox* listBox = new wxListBox(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, 0, NULL, wxLB_SINGLE | wxLB_HSCROLL);
+    listBox->Append(m_SizeNames);
+
+
+    sizer->Add(new wxStaticLine(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL), wxSizerFlags().Expand().Border(wxRIGHT | wxLEFT, 7));
+    sizer->AddSpacer(5);
+
+    wxSizer* buttonSizer = new wxBoxSizer(wxHORIZONTAL);
+    buttonSizer->Add(new wxButton(this, wxID_OK, _("OK")));
+    buttonSizer->AddSpacer(5);
+    buttonSizer->Add(new wxButton(this, wxID_CANCEL, _("Cancel")));
+
+    sizer->Add(buttonSizer, wxSizerFlags().Align(wxALIGN_RIGHT | wxALIGN_BOTTOM).Border(wxRIGHT | wxBOTTOM, 10));
+
+    SetSizerAndFit(sizer);
+    Layout();
+    Thaw();
+}
+
+size_t MapResizeDialog::GetNewSize() const
+{
+    return m_NewSize;
+}
+
+void MapResizeDialog::OnListBox(wxCommandEvent& evt)
+{
+    int index = evt.GetInt();
+    if (index < 0 || index >= m_SizeTiles.size())
+        return;
+
+    m_NewSize = m_SizeTiles[index];
+    
+    if (evt.GetEventType() == wxEVT_COMMAND_LISTBOX_DOUBLECLICKED)
+    {
+        EndModal(wxID_OK);
+    }
+}
+
+void MapResizeDialog::OnCancel(wxCommandEvent& WXUNUSED(evt))
+{
+    EndModal(wxID_CANCEL);
+}
+
+void MapResizeDialog::OnOK(wxCommandEvent& WXUNUSED(evt))
+{
+    EndModal(wxID_OK);
+}
+
+BEGIN_EVENT_TABLE(MapResizeDialog, wxDialog)
+    EVT_BUTTON(wxID_CANCEL, MapResizeDialog::OnCancel)
+    EVT_BUTTON(wxID_OK, MapResizeDialog::OnOK)
+    EVT_LISTBOX(wxID_ANY, MapResizeDialog::OnListBox)
+    EVT_LISTBOX_DCLICK(wxID_ANY, MapResizeDialog::OnListBox)
+END_EVENT_TABLE()
+ No newline at end of file

new file source/tools/atlas/AtlasUI/CustomControls/MapResizeDialog/MapResizeDialog.h

@@ +1 @@
+/* Copyright (C) 2016 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_MAPRESIZEDIALOG
+#define INCLUDED_MAPRESIZEDIALOG
+
+#include <wx/dialog.h>
+
+class MapResizeDialog : public wxDialog
+{
+public:
+    MapResizeDialog(wxWindow* parent, size_t currentSize);
+
+    /**
+     * Returns selected new size.
+     */
+    size_t GetNewSize() const;
+
+private:
+    void OnCancel(wxCommandEvent& evt);
+    void OnOK(wxCommandEvent& evt);
+    void OnListBox(wxCommandEvent& evt);
+
+    size_t m_NewSize;
+    wxArrayString m_SizeNames;
+    std::vector<size_t> m_SizeTiles;
+
+    DECLARE_EVENT_TABLE();
+};
+
+#endif // INCLUDED_MAPRESIZEDIALOG
+ No newline at end of file

source/tools/atlas/AtlasUI/ScenarioEditor/Sections/Terrain/Terrain.cpp

@@ -23 +23 @@
 #include "ScenarioEditor/ScenarioEditor.h"
 #include "ScenarioEditor/Tools/Common/Brushes.h"
 #include "ScenarioEditor/Tools/Common/MiscState.h"
+#include "MapResizeDialog/MapResizeDialog.h"
 
 #include "GameInterface/Messages.h"
 
@@ -279 +280 @@
 
 void TerrainSidebar::OnResizeMap(wxCommandEvent& WXUNUSED(evt))
 {
-    wxArrayString sizeNames;
-    std::vector<size_t> sizeTiles;
-
-    // Load the map sizes list
-    AtlasMessage::qGetMapSizes qrySizes;
-    qrySizes.Post();
-    AtObj sizes = AtlasObject::LoadFromJSON(*qrySizes.sizes);
-    for (AtIter s = sizes["Data"]["item"]; s.defined(); ++s)
-    {
-        long tiles = 0;
-        wxString(s["Tiles"]).ToLong(&tiles);
-        sizeNames.Add(wxString(s["Name"]));
-        sizeTiles.push_back((size_t)tiles);
-    }
 
-    // TODO: set default based on current map size
+    AtlasMessage::qGetCurrentMapSize qrySize;
+    qrySize.Post();
 
-    wxSingleChoiceDialog dlg(this, _("Select new map size. WARNING: This probably only works reliably on blank maps."),
-            _("Resize map"), sizeNames);
+    MapResizeDialog dlg(this, qrySize.size);
 
     if (dlg.ShowModal() != wxID_OK)
         return;
-
-    size_t tiles = sizeTiles.at(dlg.GetSelection());
-    POST_COMMAND(ResizeMap, (tiles));
+    
+    POST_COMMAND(ResizeMap, (dlg.GetNewSize()));
 }
 
 BEGIN_EVENT_TABLE(TerrainSidebar, Sidebar)

source/tools/atlas/GameInterface/Handlers/MapHandlers.cpp

@@ -312 +312 @@
     msg->data = g_Game->GetSimulation2()->GetRMSData();
 }
 
+QUERYHANDLER(GetCurrentMapSize)
+{
+    msg->size = g_Game->GetWorld()->GetTerrain()->GetTilesPerSide();
+}
+
 BEGIN_COMMAND(ResizeMap)
 {
     int m_OldTiles, m_NewTiles;

source/tools/atlas/GameInterface/Messages.h

@@ -193 +193 @@
         ((std::string, sizes))
         );
 
+QUERY(GetCurrentMapSize,
+        ,
+        ((int, size))
+        );
+
 QUERY(GetRMSData,
         ,
         ((std::vector<std::string>, data))

build/premake/premake4.lua

@@ -1118 +1118 @@
         "CustomControls/FileHistory",
         "CustomControls/HighResTimer",
         "CustomControls/MapDialog",
+        "CustomControls/MapResizeDialog",
         "CustomControls/SnapSplitterWindow",
         "CustomControls/VirtualDirTreeCtrl",
         "CustomControls/Windows",