Performance fixes.
[oweals/minetest.git] / src / map.h
1 /*
2 Minetest
3 Copyright (C) 2010-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 #ifndef MAP_HEADER
21 #define MAP_HEADER
22
23 #include <iostream>
24 #include <sstream>
25 #include <set>
26 #include <map>
27 #include <list>
28
29 #include "irrlichttypes_bloated.h"
30 #include "mapnode.h"
31 #include "constants.h"
32 #include "voxel.h"
33 #include "modifiedstate.h"
34 #include "util/container.h"
35 #include "nodetimer.h"
36
37 class Database;
38 class ClientMap;
39 class MapSector;
40 class ServerMapSector;
41 class MapBlock;
42 class NodeMetadata;
43 class IGameDef;
44 class IRollbackManager;
45 class EmergeManager;
46 class ServerEnvironment;
47 struct BlockMakeData;
48 struct MapgenParams;
49
50
51 /*
52         MapEditEvent
53 */
54
55 #define MAPTYPE_BASE 0
56 #define MAPTYPE_SERVER 1
57 #define MAPTYPE_CLIENT 2
58
59 enum MapEditEventType{
60         // Node added (changed from air or something else to something)
61         MEET_ADDNODE,
62         // Node removed (changed to air)
63         MEET_REMOVENODE,
64         // Node swapped (changed without metadata change)
65         MEET_SWAPNODE,
66         // Node metadata of block changed (not knowing which node exactly)
67         // p stores block coordinate
68         MEET_BLOCK_NODE_METADATA_CHANGED,
69         // Anything else (modified_blocks are set unsent)
70         MEET_OTHER
71 };
72
73 struct MapEditEvent
74 {
75         MapEditEventType type;
76         v3s16 p;
77         MapNode n;
78         std::set<v3s16> modified_blocks;
79         u16 already_known_by_peer;
80
81         MapEditEvent():
82                 type(MEET_OTHER),
83                 already_known_by_peer(0)
84         {
85         }
86
87         MapEditEvent * clone()
88         {
89                 MapEditEvent *event = new MapEditEvent();
90                 event->type = type;
91                 event->p = p;
92                 event->n = n;
93                 event->modified_blocks = modified_blocks;
94                 return event;
95         }
96
97         VoxelArea getArea()
98         {
99                 switch(type){
100                 case MEET_ADDNODE:
101                         return VoxelArea(p);
102                 case MEET_REMOVENODE:
103                         return VoxelArea(p);
104                 case MEET_SWAPNODE:
105                         return VoxelArea(p);
106                 case MEET_BLOCK_NODE_METADATA_CHANGED:
107                 {
108                         v3s16 np1 = p*MAP_BLOCKSIZE;
109                         v3s16 np2 = np1 + v3s16(1,1,1)*MAP_BLOCKSIZE - v3s16(1,1,1);
110                         return VoxelArea(np1, np2);
111                 }
112                 case MEET_OTHER:
113                 {
114                         VoxelArea a;
115                         for(std::set<v3s16>::iterator
116                                         i = modified_blocks.begin();
117                                         i != modified_blocks.end(); ++i)
118                         {
119                                 v3s16 p = *i;
120                                 v3s16 np1 = p*MAP_BLOCKSIZE;
121                                 v3s16 np2 = np1 + v3s16(1,1,1)*MAP_BLOCKSIZE - v3s16(1,1,1);
122                                 a.addPoint(np1);
123                                 a.addPoint(np2);
124                         }
125                         return a;
126                 }
127                 }
128                 return VoxelArea();
129         }
130 };
131
132 class MapEventReceiver
133 {
134 public:
135         // event shall be deleted by caller after the call.
136         virtual void onMapEditEvent(MapEditEvent *event) = 0;
137 };
138
139 class Map /*: public NodeContainer*/
140 {
141 public:
142
143         Map(std::ostream &dout, IGameDef *gamedef);
144         virtual ~Map();
145
146         /*virtual u16 nodeContainerId() const
147         {
148                 return NODECONTAINER_ID_MAP;
149         }*/
150
151         virtual s32 mapType() const
152         {
153                 return MAPTYPE_BASE;
154         }
155
156         /*
157                 Drop (client) or delete (server) the map.
158         */
159         virtual void drop()
160         {
161                 delete this;
162         }
163
164         void addEventReceiver(MapEventReceiver *event_receiver);
165         void removeEventReceiver(MapEventReceiver *event_receiver);
166         // event shall be deleted by caller after the call.
167         void dispatchEvent(MapEditEvent *event);
168
169         // On failure returns NULL
170         MapSector * getSectorNoGenerateNoExNoLock(v2s16 p2d);
171         // Same as the above (there exists no lock anymore)
172         MapSector * getSectorNoGenerateNoEx(v2s16 p2d);
173         // On failure throws InvalidPositionException
174         MapSector * getSectorNoGenerate(v2s16 p2d);
175         // Gets an existing sector or creates an empty one
176         //MapSector * getSectorCreate(v2s16 p2d);
177
178         /*
179                 This is overloaded by ClientMap and ServerMap to allow
180                 their differing fetch methods.
181         */
182         virtual MapSector * emergeSector(v2s16 p){ return NULL; }
183         virtual MapSector * emergeSector(v2s16 p,
184                         std::map<v3s16, MapBlock*> &changed_blocks){ return NULL; }
185
186         // Returns InvalidPositionException if not found
187         MapBlock * getBlockNoCreate(v3s16 p);
188         // Returns NULL if not found
189         MapBlock * getBlockNoCreateNoEx(v3s16 p);
190
191         /* Server overrides */
192         virtual MapBlock * emergeBlock(v3s16 p, bool create_blank=true)
193         { return getBlockNoCreateNoEx(p); }
194
195         // Returns InvalidPositionException if not found
196         bool isNodeUnderground(v3s16 p);
197
198         bool isValidPosition(v3s16 p);
199
200         // throws InvalidPositionException if not found
201         void setNode(v3s16 p, MapNode & n);
202
203         // Returns a CONTENT_IGNORE node if not found
204         // If is_valid_position is not NULL then this will be set to true if the
205         // position is valid, otherwise false
206         MapNode getNodeNoEx(v3s16 p, bool *is_valid_position = NULL);
207
208         void unspreadLight(enum LightBank bank,
209                         std::map<v3s16, u8> & from_nodes,
210                         std::set<v3s16> & light_sources,
211                         std::map<v3s16, MapBlock*> & modified_blocks);
212
213         void unLightNeighbors(enum LightBank bank,
214                         v3s16 pos, u8 lightwas,
215                         std::set<v3s16> & light_sources,
216                         std::map<v3s16, MapBlock*> & modified_blocks);
217
218         void spreadLight(enum LightBank bank,
219                         std::set<v3s16> & from_nodes,
220                         std::map<v3s16, MapBlock*> & modified_blocks);
221
222         void lightNeighbors(enum LightBank bank,
223                         v3s16 pos,
224                         std::map<v3s16, MapBlock*> & modified_blocks);
225
226         v3s16 getBrightestNeighbour(enum LightBank bank, v3s16 p);
227
228         s16 propagateSunlight(v3s16 start,
229                         std::map<v3s16, MapBlock*> & modified_blocks);
230
231         void updateLighting(enum LightBank bank,
232                         std::map<v3s16, MapBlock*>  & a_blocks,
233                         std::map<v3s16, MapBlock*> & modified_blocks);
234
235         void updateLighting(std::map<v3s16, MapBlock*>  & a_blocks,
236                         std::map<v3s16, MapBlock*> & modified_blocks);
237
238         /*
239                 These handle lighting but not faces.
240         */
241         void addNodeAndUpdate(v3s16 p, MapNode n,
242                         std::map<v3s16, MapBlock*> &modified_blocks,
243                         bool remove_metadata = true);
244         void removeNodeAndUpdate(v3s16 p,
245                         std::map<v3s16, MapBlock*> &modified_blocks);
246
247         /*
248                 Wrappers for the latter ones.
249                 These emit events.
250                 Return true if succeeded, false if not.
251         */
252         bool addNodeWithEvent(v3s16 p, MapNode n, bool remove_metadata = true);
253         bool removeNodeWithEvent(v3s16 p);
254
255         /*
256                 Takes the blocks at the edges into account
257         */
258         bool getDayNightDiff(v3s16 blockpos);
259
260         //core::aabbox3d<s16> getDisplayedBlockArea();
261
262         //bool updateChangedVisibleArea();
263
264         // Call these before and after saving of many blocks
265         virtual void beginSave() {return;};
266         virtual void endSave() {return;};
267
268         virtual void save(ModifiedState save_level){assert(0);};
269
270         // Server implements this.
271         // Client leaves it as no-op.
272         virtual bool saveBlock(MapBlock *block) { return false; };
273
274         /*
275                 Updates usage timers and unloads unused blocks and sectors.
276                 Saves modified blocks before unloading on MAPTYPE_SERVER.
277         */
278         void timerUpdate(float dtime, float unload_timeout,
279                         std::list<v3s16> *unloaded_blocks=NULL);
280
281         /*
282                 Unloads all blocks with a zero refCount().
283                 Saves modified blocks before unloading on MAPTYPE_SERVER.
284         */
285         void unloadUnreferencedBlocks(std::list<v3s16> *unloaded_blocks=NULL);
286
287         // Deletes sectors and their blocks from memory
288         // Takes cache into account
289         // If deleted sector is in sector cache, clears cache
290         void deleteSectors(std::list<v2s16> &list);
291
292 #if 0
293         /*
294                 Unload unused data
295                 = flush changed to disk and delete from memory, if usage timer of
296                   block is more than timeout
297         */
298         void unloadUnusedData(float timeout,
299                         core::list<v3s16> *deleted_blocks=NULL);
300 #endif
301
302         // For debug printing. Prints "Map: ", "ServerMap: " or "ClientMap: "
303         virtual void PrintInfo(std::ostream &out);
304
305         void transformLiquids(std::map<v3s16, MapBlock*> & modified_blocks);
306
307         /*
308                 Node metadata
309                 These are basically coordinate wrappers to MapBlock
310         */
311
312         NodeMetadata* getNodeMetadata(v3s16 p);
313
314         /**
315          * Sets metadata for a node.
316          * This method sets the metadata for a given node.
317          * On success, it returns @c true and the object pointed to
318          * by @p meta is then managed by the system and should
319          * not be deleted by the caller.
320          *
321          * In case of failure, the method returns @c false and the
322          * caller is still responsible for deleting the object!
323          *
324          * @param p node coordinates
325          * @param meta pointer to @c NodeMetadata object
326          * @return @c true on success, false on failure
327          */
328         bool setNodeMetadata(v3s16 p, NodeMetadata *meta);
329         void removeNodeMetadata(v3s16 p);
330
331         /*
332                 Node Timers
333                 These are basically coordinate wrappers to MapBlock
334         */
335
336         NodeTimer getNodeTimer(v3s16 p);
337         void setNodeTimer(v3s16 p, NodeTimer t);
338         void removeNodeTimer(v3s16 p);
339
340         /*
341                 Misc.
342         */
343         std::map<v2s16, MapSector*> *getSectorsPtr(){return &m_sectors;}
344
345         /*
346                 Variables
347         */
348
349         void transforming_liquid_add(v3s16 p);
350         s32 transforming_liquid_size();
351
352 protected:
353         friend class LuaVoxelManip;
354
355         std::ostream &m_dout; // A bit deprecated, could be removed
356
357         IGameDef *m_gamedef;
358
359         std::set<MapEventReceiver*> m_event_receivers;
360
361         std::map<v2s16, MapSector*> m_sectors;
362
363         // Be sure to set this to NULL when the cached sector is deleted
364         MapSector *m_sector_cache;
365         v2s16 m_sector_cache_p;
366
367         // Queued transforming water nodes
368         UniqueQueue<v3s16> m_transforming_liquid;
369
370 private:
371         f32 m_transforming_liquid_loop_count_multiplier;
372         u32 m_unprocessed_count;
373         u32 m_inc_trending_up_start_time; // milliseconds
374         bool m_queue_size_timer_started;
375 };
376
377 /*
378         ServerMap
379
380         This is the only map class that is able to generate map.
381 */
382
383 class ServerMap : public Map
384 {
385 public:
386         /*
387                 savedir: directory to which map data should be saved
388         */
389         ServerMap(std::string savedir, IGameDef *gamedef, EmergeManager *emerge);
390         ~ServerMap();
391
392         s32 mapType() const
393         {
394                 return MAPTYPE_SERVER;
395         }
396
397         /*
398                 Get a sector from somewhere.
399                 - Check memory
400                 - Check disk (doesn't load blocks)
401                 - Create blank one
402         */
403         ServerMapSector * createSector(v2s16 p);
404
405         /*
406                 Blocks are generated by using these and makeBlock().
407         */
408         bool initBlockMake(BlockMakeData *data, v3s16 blockpos);
409         void finishBlockMake(BlockMakeData *data,
410                         std::map<v3s16, MapBlock*> &changed_blocks);
411
412         /*
413                 Get a block from somewhere.
414                 - Memory
415                 - Create blank
416         */
417         MapBlock * createBlock(v3s16 p);
418
419         /*
420                 Forcefully get a block from somewhere.
421                 - Memory
422                 - Load from disk
423                 - Create blank filled with CONTENT_IGNORE
424
425         */
426         MapBlock * emergeBlock(v3s16 p, bool create_blank=true);
427
428         /*
429                 Try to get a block.
430                 If it does not exist in memory, add it to the emerge queue.
431                 - Memory
432                 - Emerge Queue (deferred disk or generate)
433         */
434         MapBlock *getBlockOrEmerge(v3s16 p3d);
435
436         // Carries out any initialization necessary before block is sent
437         void prepareBlock(MapBlock *block);
438
439         // Helper for placing objects on ground level
440         s16 findGroundLevel(v2s16 p2d);
441
442         /*
443                 Misc. helper functions for fiddling with directory and file
444                 names when saving
445         */
446         void createDirs(std::string path);
447         // returns something like "map/sectors/xxxxxxxx"
448         std::string getSectorDir(v2s16 pos, int layout = 2);
449         // dirname: final directory name
450         v2s16 getSectorPos(std::string dirname);
451         v3s16 getBlockPos(std::string sectordir, std::string blockfile);
452         static std::string getBlockFilename(v3s16 p);
453
454         /*
455                 Database functions
456         */
457         // Verify we can read/write to the database
458         void verifyDatabase();
459
460         // Returns true if the database file does not exist
461         bool loadFromFolders();
462
463         // Call these before and after saving of blocks
464         void beginSave();
465         void endSave();
466
467         void save(ModifiedState save_level);
468         void listAllLoadableBlocks(std::list<v3s16> &dst);
469         void listAllLoadedBlocks(std::list<v3s16> &dst);
470         // Saves map seed and possibly other stuff
471         void saveMapMeta();
472         void loadMapMeta();
473
474         /*void saveChunkMeta();
475         void loadChunkMeta();*/
476
477         // The sector mutex should be locked when calling most of these
478
479         // This only saves sector-specific data such as the heightmap
480         // (no MapBlocks)
481         // DEPRECATED? Sectors have no metadata anymore.
482         void saveSectorMeta(ServerMapSector *sector);
483         MapSector* loadSectorMeta(std::string dirname, bool save_after_load);
484         bool loadSectorMeta(v2s16 p2d);
485
486         // Full load of a sector including all blocks.
487         // returns true on success, false on failure.
488         bool loadSectorFull(v2s16 p2d);
489         // If sector is not found in memory, try to load it from disk.
490         // Returns true if sector now resides in memory
491         //bool deFlushSector(v2s16 p2d);
492
493         bool saveBlock(MapBlock *block, Database *db);
494         bool saveBlock(MapBlock *block);
495         // This will generate a sector with getSector if not found.
496         void loadBlock(std::string sectordir, std::string blockfile, MapSector *sector, bool save_after_load=false);
497         MapBlock* loadBlock(v3s16 p);
498         // Database version
499         void loadBlock(std::string *blob, v3s16 p3d, MapSector *sector, bool save_after_load=false);
500
501         void updateVManip(v3s16 pos);
502
503         // For debug printing
504         virtual void PrintInfo(std::ostream &out);
505
506         bool isSavingEnabled(){ return m_map_saving_enabled; }
507
508         u64 getSeed();
509         s16 getWaterLevel();
510
511 private:
512         // Emerge manager
513         EmergeManager *m_emerge;
514
515         std::string m_savedir;
516         bool m_map_saving_enabled;
517
518 #if 0
519         // Chunk size in MapSectors
520         // If 0, chunks are disabled.
521         s16 m_chunksize;
522         // Chunks
523         core::map<v2s16, MapChunk*> m_chunks;
524 #endif
525
526         /*
527                 Metadata is re-written on disk only if this is true.
528                 This is reset to false when written on disk.
529         */
530         bool m_map_metadata_changed;
531         Database *dbase;
532 };
533
534
535 #define VMANIP_BLOCK_DATA_INEXIST     1
536 #define VMANIP_BLOCK_CONTAINS_CIGNORE 2
537
538 class MMVManip : public VoxelManipulator
539 {
540 public:
541         MMVManip(Map *map);
542         virtual ~MMVManip();
543
544         virtual void clear()
545         {
546                 VoxelManipulator::clear();
547                 m_loaded_blocks.clear();
548         }
549
550         void setMap(Map *map)
551         {m_map = map;}
552
553         void initialEmerge(v3s16 blockpos_min, v3s16 blockpos_max,
554                 bool load_if_inexistent = true);
555
556         // This is much faster with big chunks of generated data
557         void blitBackAll(std::map<v3s16, MapBlock*> * modified_blocks,
558                 bool overwrite_generated = true);
559
560         bool m_is_dirty;
561
562 protected:
563         bool m_create_area;
564         Map *m_map;
565         /*
566                 key = blockpos
567                 value = flags describing the block
568         */
569         std::map<v3s16, u8> m_loaded_blocks;
570 };
571
572 #endif