src/database-dummy.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License along
  16 with this program; if not, write to the Free Software Foundation, Inc.,
  17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 /*
  21 Dummy "database" class
  22 */
  23
  24
  25 #include "database-dummy.h"
  26
  27 #include "map.h"
  28 #include "mapsector.h"
  29 #include "mapblock.h"
  30 #include "serialization.h"
  31 #include "main.h"
  32 #include "settings.h"
  33 #include "log.h"
  34
  35 Database_Dummy::Database_Dummy(ServerMap *map)
  36 {
  37         srvmap = map;
  38 }
  39
  40 int Database_Dummy::Initialized(void)
  41 {
  42         return 1;
  43 }
  44
  45 void Database_Dummy::beginSave() {}
  46 void Database_Dummy::endSave() {}
  47
  48 bool Database_Dummy::saveBlock(MapBlock *block)
  49 {
  50         DSTACK(__FUNCTION_NAME);
  51         /*
  52                 Dummy blocks are not written
  53         */
  54         if(block->isDummy())
  55         {
  56                 v3s16 p = block->getPos();
  57                 infostream<<"Database_Dummy::saveBlock(): WARNING: Not writing dummy block "
  58                                 <<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;
  59                 return true;
  60         }
  61
  62         // Format used for writing
  63         u8 version = SER_FMT_VER_HIGHEST_WRITE;
  64         // Get destination
  65         v3s16 p3d = block->getPos();
  66
  67         /*
  68                 [0] u8 serialization version
  69                 [1] data
  70         */
  71
  72         std::ostringstream o(std::ios_base::binary);
  73         o.write((char*)&version, 1);
  74         // Write basic data
  75         block->serialize(o, version, true);
  76         // Write block to database
  77         std::string tmp = o.str();
  78
  79         m_database[getBlockAsInteger(p3d)] = tmp;
  80         // We just wrote it to the disk so clear modified flag
  81         block->resetModified();
  82         return true;
  83 }
  84
  85 MapBlock* Database_Dummy::loadBlock(v3s16 blockpos)
  86 {
  87         v2s16 p2d(blockpos.X, blockpos.Z);
  88
  89         if(m_database.count(getBlockAsInteger(blockpos))) {
  90                 /*
  91                         Make sure sector is loaded
  92                 */
  93                 MapSector *sector = srvmap->createSector(p2d);
  94                 /*
  95                         Load block
  96                 */
  97                 std::string datastr = m_database[getBlockAsInteger(blockpos)];
  98 //                srvmap->loadBlock(&datastr, blockpos, sector, false);
  99
 100                 try {
 101                         std::istringstream is(datastr, std::ios_base::binary);
 102                         u8 version = SER_FMT_VER_INVALID;
 103                         is.read((char*)&version, 1);
 104
 105                         if(is.fail())
 106                                 throw SerializationError("ServerMap::loadBlock(): Failed"
 107                                                      " to read MapBlock version");
 108
 109                         MapBlock *block = NULL;
 110                         bool created_new = false;
 111                         block = sector->getBlockNoCreateNoEx(blockpos.Y);
 112                         if(block == NULL)
 113                         {
 114                                 block = sector->createBlankBlockNoInsert(blockpos.Y);
 115                                 created_new = true;
 116                         }
 117                         // Read basic data
 118                         block->deSerialize(is, version, true);
 119                         // If it's a new block, insert it to the map
 120                         if(created_new)
 121                                 sector->insertBlock(block);
 122                         /*
 123                                 Save blocks loaded in old format in new format
 124                         */
 125
 126                         //if(version < SER_FMT_VER_HIGHEST || save_after_load)
 127                         // Only save if asked to; no need to update version
 128                         //if(save_after_load)
 129                         //      saveBlock(block);
 130                         // We just loaded it from, so it's up-to-date.
 131                         block->resetModified();
 132
 133                 }
 134                 catch(SerializationError &e)
 135                 {
 136                         errorstream<<"Invalid block data in database"
 137                                      <<" ("<<blockpos.X<<","<<blockpos.Y<<","<<blockpos.Z<<")"
 138                                      <<" (SerializationError): "<<e.what()<<std::endl;
 139                      // TODO: Block should be marked as invalid in memory so that it is
 140                      // not touched but the game can run
 141
 142                         if(g_settings->getBool("ignore_world_load_errors")){
 143                              errorstream<<"Ignoring block load error. Duck and cover! "
 144                                              <<"(ignore_world_load_errors)"<<std::endl;
 145                         } else {
 146                              throw SerializationError("Invalid block data in database");
 147                              //assert(0);
 148                         }
 149                 }
 150
 151                 return srvmap->getBlockNoCreateNoEx(blockpos);  // should not be using this here
 152         }
 153         return(NULL);
 154 }
 155
 156 void Database_Dummy::listAllLoadableBlocks(std::list<v3s16> &dst)
 157 {
 158         for(std::map<u64, std::string>::iterator x = m_database.begin(); x != m_database.end(); ++x)
 159         {
 160                 v3s16 p = getIntegerAsBlock(x->first);
 161                 //dstream<<"block_i="<<block_i<<" p="<<PP(p)<<std::endl;
 162                 dst.push_back(p);
 163         }
 164 }
 165
 166 Database_Dummy::~Database_Dummy()
 167 {
 168         m_database.clear();
 169 }