3 Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
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.
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.
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.
28 #include "irrlichttypes_bloated.h"
31 #include "constants.h"
33 #include "modifiedstate.h"
34 #include "util/container.h"
35 #include "util/metricsbackend.h"
36 #include "util/numeric.h"
37 #include "nodetimer.h"
38 #include "map_settings_manager.h"
45 class ServerMapSector;
49 class IRollbackManager;
52 class ServerEnvironment;
59 enum MapEditEventType{
60 // Node added (changed from air or something else to something)
62 // Node removed (changed to air)
64 // Node swapped (changed without metadata change)
66 // Node metadata changed
67 MEET_BLOCK_NODE_METADATA_CHANGED,
68 // Anything else (modified_blocks are set unsent)
74 MapEditEventType type = MEET_OTHER;
76 MapNode n = CONTENT_AIR;
77 std::vector<v3s16> modified_blocks; // Represents a set
78 bool is_private_change = false;
80 MapEditEvent() = default;
82 // Sets the event's position and marks the block as modified.
83 void setPositionModified(v3s16 pos)
85 assert(modified_blocks.empty()); // only meant for initialization (once)
87 modified_blocks.push_back(getNodeBlockPos(pos));
90 void setModifiedBlocks(const std::map<v3s16, MapBlock *> blocks)
92 assert(modified_blocks.empty()); // only meant for initialization (once)
93 modified_blocks.reserve(blocks.size());
94 for (const auto &block : blocks)
95 modified_blocks.push_back(block.first);
98 VoxelArea getArea() const
102 case MEET_REMOVENODE:
104 case MEET_BLOCK_NODE_METADATA_CHANGED:
109 for (v3s16 p : modified_blocks) {
110 v3s16 np1 = p*MAP_BLOCKSIZE;
111 v3s16 np2 = np1 + v3s16(1,1,1)*MAP_BLOCKSIZE - v3s16(1,1,1);
122 class MapEventReceiver
125 // event shall be deleted by caller after the call.
126 virtual void onMapEditEvent(const MapEditEvent &event) = 0;
129 class Map /*: public NodeContainer*/
133 Map(IGameDef *gamedef);
135 DISABLE_CLASS_COPY(Map);
138 Drop (client) or delete (server) the map.
145 void addEventReceiver(MapEventReceiver *event_receiver);
146 void removeEventReceiver(MapEventReceiver *event_receiver);
147 // event shall be deleted by caller after the call.
148 void dispatchEvent(const MapEditEvent &event);
150 // On failure returns NULL
151 MapSector * getSectorNoGenerateNoLock(v2s16 p2d);
152 // Same as the above (there exists no lock anymore)
153 MapSector * getSectorNoGenerate(v2s16 p2d);
156 This is overloaded by ClientMap and ServerMap to allow
157 their differing fetch methods.
159 virtual MapSector * emergeSector(v2s16 p){ return NULL; }
161 // Returns InvalidPositionException if not found
162 MapBlock * getBlockNoCreate(v3s16 p);
163 // Returns NULL if not found
164 MapBlock * getBlockNoCreateNoEx(v3s16 p);
166 /* Server overrides */
167 virtual MapBlock * emergeBlock(v3s16 p, bool create_blank=true)
168 { return getBlockNoCreateNoEx(p); }
170 inline const NodeDefManager * getNodeDefManager() { return m_nodedef; }
172 bool isValidPosition(v3s16 p);
174 // throws InvalidPositionException if not found
175 void setNode(v3s16 p, MapNode n);
177 // Returns a CONTENT_IGNORE node if not found
178 // If is_valid_position is not NULL then this will be set to true if the
179 // position is valid, otherwise false
180 MapNode getNode(v3s16 p, bool *is_valid_position = NULL);
183 These handle lighting but not faces.
185 virtual void addNodeAndUpdate(v3s16 p, MapNode n,
186 std::map<v3s16, MapBlock*> &modified_blocks,
187 bool remove_metadata = true);
188 void removeNodeAndUpdate(v3s16 p,
189 std::map<v3s16, MapBlock*> &modified_blocks);
192 Wrappers for the latter ones.
194 Return true if succeeded, false if not.
196 bool addNodeWithEvent(v3s16 p, MapNode n, bool remove_metadata = true);
197 bool removeNodeWithEvent(v3s16 p);
199 // Call these before and after saving of many blocks
200 virtual void beginSave() {}
201 virtual void endSave() {}
203 virtual void save(ModifiedState save_level) { FATAL_ERROR("FIXME"); }
206 Return true unless the map definitely cannot save blocks.
208 virtual bool maySaveBlocks() { return true; }
210 // Server implements these.
211 // Client leaves them as no-op.
212 virtual bool saveBlock(MapBlock *block) { return false; }
213 virtual bool deleteBlock(v3s16 blockpos) { return false; }
216 Updates usage timers and unloads unused blocks and sectors.
217 Saves modified blocks before unloading if possible.
219 void timerUpdate(float dtime, float unload_timeout, s32 max_loaded_blocks,
220 std::vector<v3s16> *unloaded_blocks=NULL);
223 Unloads all blocks with a zero refCount().
224 Saves modified blocks before unloading if possible.
226 void unloadUnreferencedBlocks(std::vector<v3s16> *unloaded_blocks=NULL);
228 // Deletes sectors and their blocks from memory
229 // Takes cache into account
230 // If deleted sector is in sector cache, clears cache
231 void deleteSectors(std::vector<v2s16> &list);
233 // For debug printing. Prints "Map: ", "ServerMap: " or "ClientMap: "
234 virtual void PrintInfo(std::ostream &out);
238 These are basically coordinate wrappers to MapBlock
241 std::vector<v3s16> findNodesWithMetadata(v3s16 p1, v3s16 p2);
242 NodeMetadata *getNodeMetadata(v3s16 p);
245 * Sets metadata for a node.
246 * This method sets the metadata for a given node.
247 * On success, it returns @c true and the object pointed to
248 * by @p meta is then managed by the system and should
249 * not be deleted by the caller.
251 * In case of failure, the method returns @c false and the
252 * caller is still responsible for deleting the object!
254 * @param p node coordinates
255 * @param meta pointer to @c NodeMetadata object
256 * @return @c true on success, false on failure
258 bool setNodeMetadata(v3s16 p, NodeMetadata *meta);
259 void removeNodeMetadata(v3s16 p);
263 These are basically coordinate wrappers to MapBlock
266 NodeTimer getNodeTimer(v3s16 p);
267 void setNodeTimer(const NodeTimer &t);
268 void removeNodeTimer(v3s16 p);
274 // Iterates through all nodes in the area in an unspecified order.
275 // The given callback takes the position as its first argument and the node
276 // as its second. If it returns false, forEachNodeInArea returns early.
278 void forEachNodeInArea(v3s16 minp, v3s16 maxp, F func)
280 v3s16 bpmin = getNodeBlockPos(minp);
281 v3s16 bpmax = getNodeBlockPos(maxp);
282 for (s16 bz = bpmin.Z; bz <= bpmax.Z; bz++)
283 for (s16 bx = bpmin.X; bx <= bpmax.X; bx++)
284 for (s16 by = bpmin.Y; by <= bpmax.Y; by++) {
285 // y is iterated innermost to make use of the sector cache.
286 v3s16 bp(bx, by, bz);
287 MapBlock *block = getBlockNoCreateNoEx(bp);
288 v3s16 basep = bp * MAP_BLOCKSIZE;
289 s16 minx_block = rangelim(minp.X - basep.X, 0, MAP_BLOCKSIZE - 1);
290 s16 miny_block = rangelim(minp.Y - basep.Y, 0, MAP_BLOCKSIZE - 1);
291 s16 minz_block = rangelim(minp.Z - basep.Z, 0, MAP_BLOCKSIZE - 1);
292 s16 maxx_block = rangelim(maxp.X - basep.X, 0, MAP_BLOCKSIZE - 1);
293 s16 maxy_block = rangelim(maxp.Y - basep.Y, 0, MAP_BLOCKSIZE - 1);
294 s16 maxz_block = rangelim(maxp.Z - basep.Z, 0, MAP_BLOCKSIZE - 1);
295 for (s16 z_block = minz_block; z_block <= maxz_block; z_block++)
296 for (s16 y_block = miny_block; y_block <= maxy_block; y_block++)
297 for (s16 x_block = minx_block; x_block <= maxx_block; x_block++) {
298 v3s16 p = basep + v3s16(x_block, y_block, z_block);
300 block->getNodeNoCheck(x_block, y_block, z_block) :
301 MapNode(CONTENT_IGNORE);
308 bool isBlockOccluded(MapBlock *block, v3s16 cam_pos_nodes);
312 std::set<MapEventReceiver*> m_event_receivers;
314 std::unordered_map<v2s16, MapSector*> m_sectors;
316 // Be sure to set this to NULL when the cached sector is deleted
317 MapSector *m_sector_cache = nullptr;
318 v2s16 m_sector_cache_p;
320 // This stores the properties of the nodes on the map.
321 const NodeDefManager *m_nodedef;
323 // Can be implemented by child class
324 virtual void reportMetrics(u64 save_time_us, u32 saved_blocks, u32 all_blocks) {}
326 bool determineAdditionalOcclusionCheck(const v3s16 &pos_camera,
327 const core::aabbox3d<s16> &block_bounds, v3s16 &check);
328 bool isOccluded(const v3s16 &pos_camera, const v3s16 &pos_target,
329 float step, float stepfac, float start_offset, float end_offset,
336 This is the only map class that is able to generate map.
339 class ServerMap : public Map
343 savedir: directory to which map data should be saved
345 ServerMap(const std::string &savedir, IGameDef *gamedef, EmergeManager *emerge, MetricsBackend *mb);
349 Get a sector from somewhere.
351 - Check disk (doesn't load blocks)
354 MapSector *createSector(v2s16 p);
357 Blocks are generated by using these and makeBlock().
359 bool blockpos_over_mapgen_limit(v3s16 p);
360 bool initBlockMake(v3s16 blockpos, BlockMakeData *data);
361 void finishBlockMake(BlockMakeData *data,
362 std::map<v3s16, MapBlock*> *changed_blocks);
365 Get a block from somewhere.
369 MapBlock *createBlock(v3s16 p);
372 Forcefully get a block from somewhere.
375 - Create blank filled with CONTENT_IGNORE
378 MapBlock *emergeBlock(v3s16 p, bool create_blank=true) override;
382 If it does not exist in memory, add it to the emerge queue.
384 - Emerge Queue (deferred disk or generate)
386 MapBlock *getBlockOrEmerge(v3s16 p3d);
388 bool isBlockInQueue(v3s16 pos);
390 void addNodeAndUpdate(v3s16 p, MapNode n,
391 std::map<v3s16, MapBlock*> &modified_blocks,
392 bool remove_metadata) override;
397 static MapDatabase *createDatabase(const std::string &name, const std::string &savedir, Settings &conf);
399 // Call these before and after saving of blocks
400 void beginSave() override;
401 void endSave() override;
403 void save(ModifiedState save_level) override;
404 void listAllLoadableBlocks(std::vector<v3s16> &dst);
405 void listAllLoadedBlocks(std::vector<v3s16> &dst);
407 MapgenParams *getMapgenParams();
409 bool saveBlock(MapBlock *block) override;
410 static bool saveBlock(MapBlock *block, MapDatabase *db, int compression_level = -1);
411 MapBlock* loadBlock(v3s16 p);
413 void loadBlock(std::string *blob, v3s16 p3d, MapSector *sector, bool save_after_load=false);
415 bool deleteBlock(v3s16 blockpos) override;
417 void updateVManip(v3s16 pos);
419 // For debug printing
420 void PrintInfo(std::ostream &out) override;
422 bool isSavingEnabled(){ return m_map_saving_enabled; }
427 * Fixes lighting in one map block.
428 * May modify other blocks as well, as light can spread
429 * out of the specified block.
430 * Returns false if the block is not generated (so nothing
431 * changed), true otherwise.
433 bool repairBlockLight(v3s16 blockpos,
434 std::map<v3s16, MapBlock *> *modified_blocks);
436 void transformLiquids(std::map<v3s16, MapBlock*> & modified_blocks,
437 ServerEnvironment *env);
439 void transforming_liquid_add(v3s16 p);
441 MapSettingsManager settings_mgr;
445 void reportMetrics(u64 save_time_us, u32 saved_blocks, u32 all_blocks) override;
448 friend class LuaVoxelManip;
451 EmergeManager *m_emerge;
453 std::string m_savedir;
454 bool m_map_saving_enabled;
456 int m_map_compression_level;
458 std::set<v3s16> m_chunks_in_progress;
460 // Queued transforming water nodes
461 UniqueQueue<v3s16> m_transforming_liquid;
462 f32 m_transforming_liquid_loop_count_multiplier = 1.0f;
463 u32 m_unprocessed_count = 0;
464 u64 m_inc_trending_up_start_time = 0; // milliseconds
465 bool m_queue_size_timer_started = false;
468 Metadata is re-written on disk only if this is true.
469 This is reset to false when written on disk.
471 bool m_map_metadata_changed = true;
472 MapDatabase *dbase = nullptr;
473 MapDatabase *dbase_ro = nullptr;
476 MetricGaugePtr m_loaded_blocks_gauge;
477 MetricCounterPtr m_save_time_counter;
478 MetricCounterPtr m_save_count_counter;
482 #define VMANIP_BLOCK_DATA_INEXIST 1
483 #define VMANIP_BLOCK_CONTAINS_CIGNORE 2
485 class MMVManip : public VoxelManipulator
489 virtual ~MMVManip() = default;
493 VoxelManipulator::clear();
494 m_loaded_blocks.clear();
497 void initialEmerge(v3s16 blockpos_min, v3s16 blockpos_max,
498 bool load_if_inexistent = true);
500 // This is much faster with big chunks of generated data
501 void blitBackAll(std::map<v3s16, MapBlock*> * modified_blocks,
502 bool overwrite_generated = true);
505 Creates a copy of this VManip including contents, the copy will not be
506 associated with a Map.
508 MMVManip *clone() const;
510 // Reassociates a copied VManip to a map
511 void reparent(Map *map);
513 // Is it impossible to call initialEmerge / blitBackAll?
514 inline bool isOrphan() const { return !m_map; }
516 bool m_is_dirty = false;
522 Map *m_map = nullptr;
525 value = flags describing the block
527 std::map<v3s16, u8> m_loaded_blocks;