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::set<v3s16> modified_blocks;
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)
86 modified_blocks.insert(getNodeBlockPos(pos));
89 VoxelArea getArea() const
95 case MEET_BLOCK_NODE_METADATA_CHANGED:
100 for (v3s16 p : modified_blocks) {
101 v3s16 np1 = p*MAP_BLOCKSIZE;
102 v3s16 np2 = np1 + v3s16(1,1,1)*MAP_BLOCKSIZE - v3s16(1,1,1);
113 class MapEventReceiver
116 // event shall be deleted by caller after the call.
117 virtual void onMapEditEvent(const MapEditEvent &event) = 0;
120 class Map /*: public NodeContainer*/
124 Map(IGameDef *gamedef);
126 DISABLE_CLASS_COPY(Map);
129 Drop (client) or delete (server) the map.
136 void addEventReceiver(MapEventReceiver *event_receiver);
137 void removeEventReceiver(MapEventReceiver *event_receiver);
138 // event shall be deleted by caller after the call.
139 void dispatchEvent(const MapEditEvent &event);
141 // On failure returns NULL
142 MapSector * getSectorNoGenerateNoLock(v2s16 p2d);
143 // Same as the above (there exists no lock anymore)
144 MapSector * getSectorNoGenerate(v2s16 p2d);
147 This is overloaded by ClientMap and ServerMap to allow
148 their differing fetch methods.
150 virtual MapSector * emergeSector(v2s16 p){ return NULL; }
152 // Returns InvalidPositionException if not found
153 MapBlock * getBlockNoCreate(v3s16 p);
154 // Returns NULL if not found
155 MapBlock * getBlockNoCreateNoEx(v3s16 p);
157 /* Server overrides */
158 virtual MapBlock * emergeBlock(v3s16 p, bool create_blank=true)
159 { return getBlockNoCreateNoEx(p); }
161 inline const NodeDefManager * getNodeDefManager() { return m_nodedef; }
163 bool isValidPosition(v3s16 p);
165 // throws InvalidPositionException if not found
166 void setNode(v3s16 p, MapNode n);
168 // Returns a CONTENT_IGNORE node if not found
169 // If is_valid_position is not NULL then this will be set to true if the
170 // position is valid, otherwise false
171 MapNode getNode(v3s16 p, bool *is_valid_position = NULL);
174 These handle lighting but not faces.
176 virtual void addNodeAndUpdate(v3s16 p, MapNode n,
177 std::map<v3s16, MapBlock*> &modified_blocks,
178 bool remove_metadata = true);
179 void removeNodeAndUpdate(v3s16 p,
180 std::map<v3s16, MapBlock*> &modified_blocks);
183 Wrappers for the latter ones.
185 Return true if succeeded, false if not.
187 bool addNodeWithEvent(v3s16 p, MapNode n, bool remove_metadata = true);
188 bool removeNodeWithEvent(v3s16 p);
190 // Call these before and after saving of many blocks
191 virtual void beginSave() {}
192 virtual void endSave() {}
194 virtual void save(ModifiedState save_level) { FATAL_ERROR("FIXME"); }
197 Return true unless the map definitely cannot save blocks.
199 virtual bool maySaveBlocks() { return true; }
201 // Server implements these.
202 // Client leaves them as no-op.
203 virtual bool saveBlock(MapBlock *block) { return false; }
204 virtual bool deleteBlock(v3s16 blockpos) { return false; }
207 Updates usage timers and unloads unused blocks and sectors.
208 Saves modified blocks before unloading if possible.
210 void timerUpdate(float dtime, float unload_timeout, s32 max_loaded_blocks,
211 std::vector<v3s16> *unloaded_blocks=NULL);
214 Unloads all blocks with a zero refCount().
215 Saves modified blocks before unloading if possible.
217 void unloadUnreferencedBlocks(std::vector<v3s16> *unloaded_blocks=NULL);
219 // Deletes sectors and their blocks from memory
220 // Takes cache into account
221 // If deleted sector is in sector cache, clears cache
222 void deleteSectors(std::vector<v2s16> &list);
224 // For debug printing. Prints "Map: ", "ServerMap: " or "ClientMap: "
225 virtual void PrintInfo(std::ostream &out);
229 These are basically coordinate wrappers to MapBlock
232 std::vector<v3s16> findNodesWithMetadata(v3s16 p1, v3s16 p2);
233 NodeMetadata *getNodeMetadata(v3s16 p);
236 * Sets metadata for a node.
237 * This method sets the metadata for a given node.
238 * On success, it returns @c true and the object pointed to
239 * by @p meta is then managed by the system and should
240 * not be deleted by the caller.
242 * In case of failure, the method returns @c false and the
243 * caller is still responsible for deleting the object!
245 * @param p node coordinates
246 * @param meta pointer to @c NodeMetadata object
247 * @return @c true on success, false on failure
249 bool setNodeMetadata(v3s16 p, NodeMetadata *meta);
250 void removeNodeMetadata(v3s16 p);
254 These are basically coordinate wrappers to MapBlock
257 NodeTimer getNodeTimer(v3s16 p);
258 void setNodeTimer(const NodeTimer &t);
259 void removeNodeTimer(v3s16 p);
265 // Iterates through all nodes in the area in an unspecified order.
266 // The given callback takes the position as its first argument and the node
267 // as its second. If it returns false, forEachNodeInArea returns early.
269 void forEachNodeInArea(v3s16 minp, v3s16 maxp, F func)
271 v3s16 bpmin = getNodeBlockPos(minp);
272 v3s16 bpmax = getNodeBlockPos(maxp);
273 for (s16 bz = bpmin.Z; bz <= bpmax.Z; bz++)
274 for (s16 bx = bpmin.X; bx <= bpmax.X; bx++)
275 for (s16 by = bpmin.Y; by <= bpmax.Y; by++) {
276 // y is iterated innermost to make use of the sector cache.
277 v3s16 bp(bx, by, bz);
278 MapBlock *block = getBlockNoCreateNoEx(bp);
279 v3s16 basep = bp * MAP_BLOCKSIZE;
280 s16 minx_block = rangelim(minp.X - basep.X, 0, MAP_BLOCKSIZE - 1);
281 s16 miny_block = rangelim(minp.Y - basep.Y, 0, MAP_BLOCKSIZE - 1);
282 s16 minz_block = rangelim(minp.Z - basep.Z, 0, MAP_BLOCKSIZE - 1);
283 s16 maxx_block = rangelim(maxp.X - basep.X, 0, MAP_BLOCKSIZE - 1);
284 s16 maxy_block = rangelim(maxp.Y - basep.Y, 0, MAP_BLOCKSIZE - 1);
285 s16 maxz_block = rangelim(maxp.Z - basep.Z, 0, MAP_BLOCKSIZE - 1);
286 for (s16 z_block = minz_block; z_block <= maxz_block; z_block++)
287 for (s16 y_block = miny_block; y_block <= maxy_block; y_block++)
288 for (s16 x_block = minx_block; x_block <= maxx_block; x_block++) {
289 v3s16 p = basep + v3s16(x_block, y_block, z_block);
291 block->getNodeNoCheck(x_block, y_block, z_block) :
292 MapNode(CONTENT_IGNORE);
299 bool isBlockOccluded(MapBlock *block, v3s16 cam_pos_nodes);
303 std::set<MapEventReceiver*> m_event_receivers;
305 std::unordered_map<v2s16, MapSector*> m_sectors;
307 // Be sure to set this to NULL when the cached sector is deleted
308 MapSector *m_sector_cache = nullptr;
309 v2s16 m_sector_cache_p;
311 // This stores the properties of the nodes on the map.
312 const NodeDefManager *m_nodedef;
314 // Can be implemented by child class
315 virtual void reportMetrics(u64 save_time_us, u32 saved_blocks, u32 all_blocks) {}
317 bool determineAdditionalOcclusionCheck(const v3s16 &pos_camera,
318 const core::aabbox3d<s16> &block_bounds, v3s16 &check);
319 bool isOccluded(const v3s16 &pos_camera, const v3s16 &pos_target,
320 float step, float stepfac, float start_offset, float end_offset,
327 This is the only map class that is able to generate map.
330 class ServerMap : public Map
334 savedir: directory to which map data should be saved
336 ServerMap(const std::string &savedir, IGameDef *gamedef, EmergeManager *emerge, MetricsBackend *mb);
340 Get a sector from somewhere.
342 - Check disk (doesn't load blocks)
345 MapSector *createSector(v2s16 p);
348 Blocks are generated by using these and makeBlock().
350 bool blockpos_over_mapgen_limit(v3s16 p);
351 bool initBlockMake(v3s16 blockpos, BlockMakeData *data);
352 void finishBlockMake(BlockMakeData *data,
353 std::map<v3s16, MapBlock*> *changed_blocks);
356 Get a block from somewhere.
360 MapBlock *createBlock(v3s16 p);
363 Forcefully get a block from somewhere.
366 - Create blank filled with CONTENT_IGNORE
369 MapBlock *emergeBlock(v3s16 p, bool create_blank=true) override;
373 If it does not exist in memory, add it to the emerge queue.
375 - Emerge Queue (deferred disk or generate)
377 MapBlock *getBlockOrEmerge(v3s16 p3d);
379 bool isBlockInQueue(v3s16 pos);
381 void addNodeAndUpdate(v3s16 p, MapNode n,
382 std::map<v3s16, MapBlock*> &modified_blocks,
383 bool remove_metadata) override;
388 static MapDatabase *createDatabase(const std::string &name, const std::string &savedir, Settings &conf);
390 // Call these before and after saving of blocks
391 void beginSave() override;
392 void endSave() override;
394 void save(ModifiedState save_level) override;
395 void listAllLoadableBlocks(std::vector<v3s16> &dst);
396 void listAllLoadedBlocks(std::vector<v3s16> &dst);
398 MapgenParams *getMapgenParams();
400 bool saveBlock(MapBlock *block) override;
401 static bool saveBlock(MapBlock *block, MapDatabase *db, int compression_level = -1);
402 MapBlock* loadBlock(v3s16 p);
404 void loadBlock(std::string *blob, v3s16 p3d, MapSector *sector, bool save_after_load=false);
406 bool deleteBlock(v3s16 blockpos) override;
408 void updateVManip(v3s16 pos);
410 // For debug printing
411 void PrintInfo(std::ostream &out) override;
413 bool isSavingEnabled(){ return m_map_saving_enabled; }
418 * Fixes lighting in one map block.
419 * May modify other blocks as well, as light can spread
420 * out of the specified block.
421 * Returns false if the block is not generated (so nothing
422 * changed), true otherwise.
424 bool repairBlockLight(v3s16 blockpos,
425 std::map<v3s16, MapBlock *> *modified_blocks);
427 void transformLiquids(std::map<v3s16, MapBlock*> & modified_blocks,
428 ServerEnvironment *env);
430 void transforming_liquid_add(v3s16 p);
432 MapSettingsManager settings_mgr;
436 void reportMetrics(u64 save_time_us, u32 saved_blocks, u32 all_blocks) override;
439 friend class LuaVoxelManip;
442 EmergeManager *m_emerge;
444 std::string m_savedir;
445 bool m_map_saving_enabled;
447 int m_map_compression_level;
449 std::set<v3s16> m_chunks_in_progress;
451 // Queued transforming water nodes
452 UniqueQueue<v3s16> m_transforming_liquid;
453 f32 m_transforming_liquid_loop_count_multiplier = 1.0f;
454 u32 m_unprocessed_count = 0;
455 u64 m_inc_trending_up_start_time = 0; // milliseconds
456 bool m_queue_size_timer_started = false;
459 Metadata is re-written on disk only if this is true.
460 This is reset to false when written on disk.
462 bool m_map_metadata_changed = true;
463 MapDatabase *dbase = nullptr;
464 MapDatabase *dbase_ro = nullptr;
467 MetricGaugePtr m_loaded_blocks_gauge;
468 MetricCounterPtr m_save_time_counter;
469 MetricCounterPtr m_save_count_counter;
473 #define VMANIP_BLOCK_DATA_INEXIST 1
474 #define VMANIP_BLOCK_CONTAINS_CIGNORE 2
476 class MMVManip : public VoxelManipulator
480 virtual ~MMVManip() = default;
484 VoxelManipulator::clear();
485 m_loaded_blocks.clear();
488 void initialEmerge(v3s16 blockpos_min, v3s16 blockpos_max,
489 bool load_if_inexistent = true);
491 // This is much faster with big chunks of generated data
492 void blitBackAll(std::map<v3s16, MapBlock*> * modified_blocks,
493 bool overwrite_generated = true);
496 Creates a copy of this VManip including contents, the copy will not be
497 associated with a Map.
499 MMVManip *clone() const;
501 // Reassociates a copied VManip to a map
502 void reparent(Map *map);
504 // Is it impossible to call initialEmerge / blitBackAll?
505 inline bool isOrphan() const { return !m_map; }
507 bool m_is_dirty = false;
513 Map *m_map = nullptr;
516 value = flags describing the block
518 std::map<v3s16, u8> m_loaded_blocks;