src/mapsector.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 #include "mapsector.h"
  21 #include "exceptions.h"
  22 #include "mapblock.h"
  23 #include "serialization.h"
  24
  25 MapSector::MapSector(Map *parent, v2s16 pos, IGameDef *gamedef):
  26                 differs_from_disk(false),
  27                 m_parent(parent),
  28                 m_pos(pos),
  29                 m_gamedef(gamedef),
  30                 m_block_cache(NULL)
  31 {
  32 }
  33
  34 MapSector::~MapSector()
  35 {
  36         deleteBlocks();
  37 }
  38
  39 void MapSector::deleteBlocks()
  40 {
  41         // Clear cache
  42         m_block_cache = NULL;
  43
  44         // Delete all
  45         for(std::map<s16, MapBlock*>::iterator i = m_blocks.begin();
  46                 i != m_blocks.end(); ++i)
  47         {
  48                 delete i->second;
  49         }
  50
  51         // Clear container
  52         m_blocks.clear();
  53 }
  54
  55 MapBlock * MapSector::getBlockBuffered(s16 y)
  56 {
  57         MapBlock *block;
  58
  59         if(m_block_cache != NULL && y == m_block_cache_y){
  60                 return m_block_cache;
  61         }
  62
  63         // If block doesn't exist, return NULL
  64         std::map<s16, MapBlock*>::iterator n = m_blocks.find(y);
  65         if(n == m_blocks.end())
  66         {
  67                 block = NULL;
  68         }
  69         // If block exists, return it
  70         else{
  71                 block = n->second;
  72         }
  73
  74         // Cache the last result
  75         m_block_cache_y = y;
  76         m_block_cache = block;
  77
  78         return block;
  79 }
  80
  81 MapBlock * MapSector::getBlockNoCreateNoEx(s16 y)
  82 {
  83         return getBlockBuffered(y);
  84 }
  85
  86 MapBlock * MapSector::createBlankBlockNoInsert(s16 y)
  87 {
  88         assert(getBlockBuffered(y) == NULL);    // Pre-condition
  89
  90         v3s16 blockpos_map(m_pos.X, y, m_pos.Y);
  91
  92         MapBlock *block = new MapBlock(m_parent, blockpos_map, m_gamedef);
  93
  94         return block;
  95 }
  96
  97 MapBlock * MapSector::createBlankBlock(s16 y)
  98 {
  99         MapBlock *block = createBlankBlockNoInsert(y);
 100
 101         m_blocks[y] = block;
 102
 103         return block;
 104 }
 105
 106 void MapSector::insertBlock(MapBlock *block)
 107 {
 108         s16 block_y = block->getPos().Y;
 109
 110         MapBlock *block2 = getBlockBuffered(block_y);
 111         if(block2 != NULL){
 112                 throw AlreadyExistsException("Block already exists");
 113         }
 114
 115         v2s16 p2d(block->getPos().X, block->getPos().Z);
 116         assert(p2d == m_pos);
 117
 118         // Insert into container
 119         m_blocks[block_y] = block;
 120 }
 121
 122 void MapSector::deleteBlock(MapBlock *block)
 123 {
 124         s16 block_y = block->getPos().Y;
 125
 126         // Clear from cache
 127         m_block_cache = NULL;
 128
 129         // Remove from container
 130         m_blocks.erase(block_y);
 131
 132         // Delete
 133         delete block;
 134 }
 135
 136 void MapSector::getBlocks(MapBlockVect &dest)
 137 {
 138         for(std::map<s16, MapBlock*>::iterator bi = m_blocks.begin();
 139                 bi != m_blocks.end(); ++bi)
 140         {
 141                 dest.push_back(bi->second);
 142         }
 143 }
 144
 145 bool MapSector::empty()
 146 {
 147         return m_blocks.empty();
 148 }
 149
 150 /*
 151         ServerMapSector
 152 */
 153
 154 ServerMapSector::ServerMapSector(Map *parent, v2s16 pos, IGameDef *gamedef):
 155                 MapSector(parent, pos, gamedef)
 156 {
 157 }
 158
 159 ServerMapSector::~ServerMapSector()
 160 {
 161 }
 162
 163 void ServerMapSector::serialize(std::ostream &os, u8 version)
 164 {
 165         if(!ser_ver_supported(version))
 166                 throw VersionMismatchException("ERROR: MapSector format not supported");
 167
 168         /*
 169                 [0] u8 serialization version
 170                 + heightmap data
 171         */
 172
 173         // Server has both of these, no need to support not having them.
 174         //assert(m_objects != NULL);
 175
 176         // Write version
 177         os.write((char*)&version, 1);
 178
 179         /*
 180                 Add stuff here, if needed
 181         */
 182
 183 }
 184
 185 ServerMapSector* ServerMapSector::deSerialize(
 186                 std::istream &is,
 187                 Map *parent,
 188                 v2s16 p2d,
 189                 std::map<v2s16, MapSector*> & sectors,
 190                 IGameDef *gamedef
 191         )
 192 {
 193         /*
 194                 [0] u8 serialization version
 195                 + heightmap data
 196         */
 197
 198         /*
 199                 Read stuff
 200         */
 201
 202         // Read version
 203         u8 version = SER_FMT_VER_INVALID;
 204         is.read((char*)&version, 1);
 205
 206         if(!ser_ver_supported(version))
 207                 throw VersionMismatchException("ERROR: MapSector format not supported");
 208
 209         /*
 210                 Add necessary reading stuff here
 211         */
 212
 213         /*
 214                 Get or create sector
 215         */
 216
 217         ServerMapSector *sector = NULL;
 218
 219         std::map<v2s16, MapSector*>::iterator n = sectors.find(p2d);
 220
 221         if(n != sectors.end())
 222         {
 223                 dstream<<"WARNING: deSerializing existent sectors not supported "
 224                                 "at the moment, because code hasn't been tested."
 225                                 <<std::endl;
 226
 227                 MapSector *sector = n->second;
 228                 assert(sector->getId() == MAPSECTOR_SERVER);
 229                 return (ServerMapSector*)sector;
 230         }
 231         else
 232         {
 233                 sector = new ServerMapSector(parent, p2d, gamedef);
 234                 sectors[p2d] = sector;
 235         }
 236
 237         /*
 238                 Set stuff in sector
 239         */
 240
 241         // Nothing here
 242
 243         return sector;
 244 }
 245
 246 #ifndef SERVER
 247 /*
 248         ClientMapSector
 249 */
 250
 251 ClientMapSector::ClientMapSector(Map *parent, v2s16 pos, IGameDef *gamedef):
 252                 MapSector(parent, pos, gamedef)
 253 {
 254 }
 255
 256 ClientMapSector::~ClientMapSector()
 257 {
 258 }
 259
 260 #endif // !SERVER
 261
 262 //END