Remove MapVoxelManipulator not really used by anyone

diff --git a/src/map.cpp b/src/map.cpp
index 814eea4c7b377d5832fa0047f9d0f9e11c5e0f39..35bd485a490eee1670652556baa2632a31956721 100644 (file)
--- a/src/map.cpp
+++ b/src/map.cpp
@@ -3484,167 +3484,10 @@ void ServerMap::PrintInfo(std::ostream &out)
        out<<"ServerMap: ";
 }
 
-/*
-       MapVoxelManipulator
-*/
-
-MapVoxelManipulator::MapVoxelManipulator(Map *map)
-{
-       m_map = map;
-}
-
-MapVoxelManipulator::~MapVoxelManipulator()
-{
-       /*infostream<<"MapVoxelManipulator: blocks: "<<m_loaded_blocks.size()
-                       <<std::endl;*/
-}
-
-void MapVoxelManipulator::emerge(VoxelArea a, s32 caller_id)
-{
-       TimeTaker timer1("emerge", &emerge_time);
-
-       // Units of these are MapBlocks
-       v3s16 p_min = getNodeBlockPos(a.MinEdge);
-       v3s16 p_max = getNodeBlockPos(a.MaxEdge);
-
-       VoxelArea block_area_nodes
-                       (p_min*MAP_BLOCKSIZE, (p_max+1)*MAP_BLOCKSIZE-v3s16(1,1,1));
-
-       addArea(block_area_nodes);
-
-       for(s32 z=p_min.Z; z<=p_max.Z; z++)
-       for(s32 y=p_min.Y; y<=p_max.Y; y++)
-       for(s32 x=p_min.X; x<=p_max.X; x++)
-       {
-               u8 flags = 0;
-               MapBlock *block;
-               v3s16 p(x,y,z);
-               std::map<v3s16, u8>::iterator n;
-               n = m_loaded_blocks.find(p);
-               if(n != m_loaded_blocks.end())
-                       continue;
-
-               bool block_data_inexistent = false;
-               try
-               {
-                       TimeTaker timer1("emerge load", &emerge_load_time);
-
-                       /*infostream<<"Loading block (caller_id="<<caller_id<<")"
-                                       <<" ("<<p.X<<","<<p.Y<<","<<p.Z<<")"
-                                       <<" wanted area: ";
-                       a.print(infostream);
-                       infostream<<std::endl;*/
-
-                       block = m_map->getBlockNoCreate(p);
-                       if(block->isDummy())
-                               block_data_inexistent = true;
-                       else
-                               block->copyTo(*this);
-               }
-               catch(InvalidPositionException &e)
-               {
-                       block_data_inexistent = true;
-               }
-
-               if(block_data_inexistent)
-               {
-                       flags |= VMANIP_BLOCK_DATA_INEXIST;
-
-                       VoxelArea a(p*MAP_BLOCKSIZE, (p+1)*MAP_BLOCKSIZE-v3s16(1,1,1));
-                       // Fill with VOXELFLAG_NO_DATA
-                       for(s32 z=a.MinEdge.Z; z<=a.MaxEdge.Z; z++)
-                       for(s32 y=a.MinEdge.Y; y<=a.MaxEdge.Y; y++)
-                       {
-                               s32 i = m_area.index(a.MinEdge.X,y,z);
-                               memset(&m_flags[i], VOXELFLAG_NO_DATA, MAP_BLOCKSIZE);
-                       }
-               }
-               /*else if (block->getNode(0, 0, 0).getContent() == CONTENT_IGNORE)
-               {
-                       // Mark that block was loaded as blank
-                       flags |= VMANIP_BLOCK_CONTAINS_CIGNORE;
-               }*/
-
-               m_loaded_blocks[p] = flags;
-       }
-
-       //infostream<<"emerge done"<<std::endl;
-}
-
-/*
-       SUGG: Add an option to only update eg. water and air nodes.
-             This will make it interfere less with important stuff if
-                 run on background.
-*/
-void MapVoxelManipulator::blitBack
-               (std::map<v3s16, MapBlock*> & modified_blocks)
-{
-       if(m_area.getExtent() == v3s16(0,0,0))
-               return;
-
-       //TimeTaker timer1("blitBack");
-
-       /*infostream<<"blitBack(): m_loaded_blocks.size()="
-                       <<m_loaded_blocks.size()<<std::endl;*/
-
-       /*
-               Initialize block cache
-       */
-       v3s16 blockpos_last;
-       MapBlock *block = NULL;
-       bool block_checked_in_modified = false;
-
-       for(s32 z=m_area.MinEdge.Z; z<=m_area.MaxEdge.Z; z++)
-       for(s32 y=m_area.MinEdge.Y; y<=m_area.MaxEdge.Y; y++)
-       for(s32 x=m_area.MinEdge.X; x<=m_area.MaxEdge.X; x++)
-       {
-               v3s16 p(x,y,z);
-
-               u8 f = m_flags[m_area.index(p)];
-               if(f & (VOXELFLAG_NO_DATA))
-                       continue;
-
-               MapNode &n = m_data[m_area.index(p)];
-
-               v3s16 blockpos = getNodeBlockPos(p);
-
-               try
-               {
-                       // Get block
-                       if(block == NULL || blockpos != blockpos_last){
-                               block = m_map->getBlockNoCreate(blockpos);
-                               blockpos_last = blockpos;
-                               block_checked_in_modified = false;
-                       }
-
-                       // Calculate relative position in block
-                       v3s16 relpos = p - blockpos * MAP_BLOCKSIZE;
-
-                       // Don't continue if nothing has changed here
-                       if(block->getNode(relpos) == n)
-                               continue;
-
-                       //m_map->setNode(m_area.MinEdge + p, n);
-                       block->setNode(relpos, n);
-
-                       /*
-                               Make sure block is in modified_blocks
-                       */
-                       if(block_checked_in_modified == false)
-                       {
-                               modified_blocks[blockpos] = block;
-                               block_checked_in_modified = true;
-                       }
-               }
-               catch(InvalidPositionException &e)
-               {
-               }
-       }
-}
-
 ManualMapVoxelManipulator::ManualMapVoxelManipulator(Map *map):
-               MapVoxelManipulator(map),
-               m_create_area(false)
+               VoxelManipulator(),
+               m_create_area(false),
+               m_map(map)
 {
 }
 
@@ -3652,12 +3495,6 @@ ManualMapVoxelManipulator::~ManualMapVoxelManipulator()
 {
 }
 
-void ManualMapVoxelManipulator::emerge(VoxelArea a, s32 caller_id)
-{
-       // Just create the area so that it can be pointed to
-       VoxelManipulator::addArea(a);
-}
-
 void ManualMapVoxelManipulator::initialEmerge(v3s16 blockpos_min,
                                                v3s16 blockpos_max, bool load_if_inexistent)
 {

diff --git a/src/map.h b/src/map.h
index 46580ed3b42520fef92dc192e7523688a9218916..7f482929e179b29222349b36eddc55e070b01405 100644 (file)
--- a/src/map.h
+++ b/src/map.h
@@ -523,14 +523,15 @@ class ServerMap : public Map
        Database *dbase;
 };
 
+
 #define VMANIP_BLOCK_DATA_INEXIST     1
 #define VMANIP_BLOCK_CONTAINS_CIGNORE 2
 
-class MapVoxelManipulator : public VoxelManipulator
+class ManualMapVoxelManipulator : public VoxelManipulator
 {
 public:
-       MapVoxelManipulator(Map *map);
-       virtual ~MapVoxelManipulator();
+       ManualMapVoxelManipulator(Map *map);
+       virtual ~ManualMapVoxelManipulator();
 
        virtual void clear()
        {
@@ -538,30 +539,9 @@ class MapVoxelManipulator : public VoxelManipulator
                m_loaded_blocks.clear();
        }
 
-       virtual void emerge(VoxelArea a, s32 caller_id=-1);
-
-       void blitBack(std::map<v3s16, MapBlock*> & modified_blocks);
-
-protected:
-       Map *m_map;
-       /*
-               key = blockpos
-               value = flags describing the block
-       */
-       std::map<v3s16, u8> m_loaded_blocks;
-};
-
-class ManualMapVoxelManipulator : public MapVoxelManipulator
-{
-public:
-       ManualMapVoxelManipulator(Map *map);
-       virtual ~ManualMapVoxelManipulator();
-
        void setMap(Map *map)
        {m_map = map;}
 
-       virtual void emerge(VoxelArea a, s32 caller_id=-1);
-
        void initialEmerge(v3s16 blockpos_min, v3s16 blockpos_max,
                                                bool load_if_inexistent = true);
 
@@ -570,6 +550,12 @@ class ManualMapVoxelManipulator : public MapVoxelManipulator
 
 protected:
        bool m_create_area;
+       Map *m_map;
+       /*
+               key = blockpos
+               value = flags describing the block
+       */
+       std::map<v3s16, u8> m_loaded_blocks;
 };
 
 #endif