X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fmap.h;h=4972046f535590329eaae6100ea18aea586122ae;hb=8b3ed78e53d8ad19d8dee3968430be258559214c;hp=3097d15b9fcc52549919ac1008d97118f55f4c21;hpb=11afcbff69c95915e5142bc4b55636ff6358ece9;p=dragonfireclient.git diff --git a/src/map.h b/src/map.h index 3097d15b9..4972046f5 100644 --- a/src/map.h +++ b/src/map.h @@ -1,6 +1,6 @@ /* -Minetest-c55 -Copyright (C) 2010-2011 celeron55, Perttu Ahola +Minetest +Copyright (C) 2010-2013 celeron55, Perttu Ahola This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by @@ -20,25 +20,21 @@ with this program; if not, write to the Free Software Foundation, Inc., #ifndef MAP_HEADER #define MAP_HEADER -#include -#include -#include #include #include +#include +#include +#include #include "irrlichttypes_bloated.h" #include "mapnode.h" #include "constants.h" #include "voxel.h" -#include "mapgen.h" //for BlockMakeData and EmergeManager #include "modifiedstate.h" #include "util/container.h" #include "nodetimer.h" -extern "C" { - #include "sqlite3.h" -} - +class Database; class ClientMap; class MapSector; class ServerMapSector; @@ -46,6 +42,10 @@ class MapBlock; class NodeMetadata; class IGameDef; class IRollbackReportSink; +class EmergeManager; +class ServerEnvironment; +struct BlockMakeData; +struct MapgenParams; /* @@ -61,6 +61,8 @@ enum MapEditEventType{ MEET_ADDNODE, // Node removed (changed to air) MEET_REMOVENODE, + // Node swapped (changed without metadata change) + MEET_SWAPNODE, // Node metadata of block changed (not knowing which node exactly) // p stores block coordinate MEET_BLOCK_NODE_METADATA_CHANGED, @@ -73,7 +75,7 @@ struct MapEditEvent MapEditEventType type; v3s16 p; MapNode n; - core::map modified_blocks; + std::set modified_blocks; u16 already_known_by_peer; MapEditEvent(): @@ -81,21 +83,14 @@ struct MapEditEvent already_known_by_peer(0) { } - + MapEditEvent * clone() { MapEditEvent *event = new MapEditEvent(); event->type = type; event->p = p; event->n = n; - for(core::map::Iterator - i = modified_blocks.getIterator(); - i.atEnd()==false; i++) - { - v3s16 p = i.getNode()->getKey(); - bool v = i.getNode()->getValue(); - event->modified_blocks.insert(p, v); - } + event->modified_blocks = modified_blocks; return event; } @@ -106,6 +101,8 @@ struct MapEditEvent return VoxelArea(p); case MEET_REMOVENODE: return VoxelArea(p); + case MEET_SWAPNODE: + return VoxelArea(p); case MEET_BLOCK_NODE_METADATA_CHANGED: { v3s16 np1 = p*MAP_BLOCKSIZE; @@ -115,11 +112,11 @@ struct MapEditEvent case MEET_OTHER: { VoxelArea a; - for(core::map::Iterator - i = modified_blocks.getIterator(); - i.atEnd()==false; i++) + for(std::set::iterator + i = modified_blocks.begin(); + i != modified_blocks.end(); ++i) { - v3s16 p = i.getNode()->getKey(); + v3s16 p = *i; v3s16 np1 = p*MAP_BLOCKSIZE; v3s16 np2 = np1 + v3s16(1,1,1)*MAP_BLOCKSIZE - v3s16(1,1,1); a.addPoint(np1); @@ -155,7 +152,7 @@ class Map /*: public NodeContainer*/ { return MAPTYPE_BASE; } - + /* Drop (client) or delete (server) the map. */ @@ -168,7 +165,7 @@ class Map /*: public NodeContainer*/ void removeEventReceiver(MapEventReceiver *event_receiver); // event shall be deleted by caller after the call. void dispatchEvent(MapEditEvent *event); - + // On failure returns NULL MapSector * getSectorNoGenerateNoExNoLock(v2s16 p2d); // Same as the above (there exists no lock anymore) @@ -184,77 +181,78 @@ class Map /*: public NodeContainer*/ */ virtual MapSector * emergeSector(v2s16 p){ return NULL; } virtual MapSector * emergeSector(v2s16 p, - core::map &changed_blocks){ return NULL; } + std::map &changed_blocks){ return NULL; } // Returns InvalidPositionException if not found MapBlock * getBlockNoCreate(v3s16 p); // Returns NULL if not found MapBlock * getBlockNoCreateNoEx(v3s16 p); - + /* Server overrides */ virtual MapBlock * emergeBlock(v3s16 p, bool allow_generate=true) { return getBlockNoCreateNoEx(p); } // Returns InvalidPositionException if not found bool isNodeUnderground(v3s16 p); - + bool isValidPosition(v3s16 p); - + // throws InvalidPositionException if not found MapNode getNode(v3s16 p); // throws InvalidPositionException if not found void setNode(v3s16 p, MapNode & n); - + // Returns a CONTENT_IGNORE node if not found MapNode getNodeNoEx(v3s16 p); void unspreadLight(enum LightBank bank, - core::map & from_nodes, - core::map & light_sources, - core::map & modified_blocks); + std::map & from_nodes, + std::set & light_sources, + std::map & modified_blocks); void unLightNeighbors(enum LightBank bank, v3s16 pos, u8 lightwas, - core::map & light_sources, - core::map & modified_blocks); - + std::set & light_sources, + std::map & modified_blocks); + void spreadLight(enum LightBank bank, - core::map & from_nodes, - core::map & modified_blocks); - + std::set & from_nodes, + std::map & modified_blocks); + void lightNeighbors(enum LightBank bank, v3s16 pos, - core::map & modified_blocks); + std::map & modified_blocks); v3s16 getBrightestNeighbour(enum LightBank bank, v3s16 p); s16 propagateSunlight(v3s16 start, - core::map & modified_blocks); - + std::map & modified_blocks); + void updateLighting(enum LightBank bank, - core::map & a_blocks, - core::map & modified_blocks); - - void updateLighting(core::map & a_blocks, - core::map & modified_blocks); - + std::map & a_blocks, + std::map & modified_blocks); + + void updateLighting(std::map & a_blocks, + std::map & modified_blocks); + /* These handle lighting but not faces. */ void addNodeAndUpdate(v3s16 p, MapNode n, - core::map &modified_blocks); + std::map &modified_blocks, + bool remove_metadata = true); void removeNodeAndUpdate(v3s16 p, - core::map &modified_blocks); + std::map &modified_blocks); /* Wrappers for the latter ones. These emit events. Return true if succeeded, false if not. */ - bool addNodeWithEvent(v3s16 p, MapNode n); + bool addNodeWithEvent(v3s16 p, MapNode n, bool remove_metadata = true); bool removeNodeWithEvent(v3s16 p); - + /* Takes the blocks at the edges into account */ @@ -267,24 +265,30 @@ class Map /*: public NodeContainer*/ // Call these before and after saving of many blocks virtual void beginSave() {return;}; virtual void endSave() {return;}; - + virtual void save(ModifiedState save_level){assert(0);}; - + // Server implements this. // Client leaves it as no-op. - virtual void saveBlock(MapBlock *block){}; + virtual bool saveBlock(MapBlock *block){ return false; }; /* Updates usage timers and unloads unused blocks and sectors. Saves modified blocks before unloading on MAPTYPE_SERVER. */ void timerUpdate(float dtime, float unload_timeout, - core::list *unloaded_blocks=NULL); - + std::list *unloaded_blocks=NULL); + + /* + Unloads all blocks with a zero refCount(). + Saves modified blocks before unloading on MAPTYPE_SERVER. + */ + void unloadUnreferencedBlocks(std::list *unloaded_blocks=NULL); + // Deletes sectors and their blocks from memory // Takes cache into account // If deleted sector is in sector cache, clears cache - void deleteSectors(core::list &list); + void deleteSectors(std::list &list); #if 0 /* @@ -298,23 +302,38 @@ class Map /*: public NodeContainer*/ // For debug printing. Prints "Map: ", "ServerMap: " or "ClientMap: " virtual void PrintInfo(std::ostream &out); - - void transformLiquids(core::map & modified_blocks); + + void transformLiquids(std::map & modified_blocks); /* Node metadata These are basically coordinate wrappers to MapBlock */ - + NodeMetadata* getNodeMetadata(v3s16 p); - void setNodeMetadata(v3s16 p, NodeMetadata *meta); + + /** + * Sets metadata for a node. + * This method sets the metadata for a given node. + * On success, it returns @c true and the object pointed to + * by @p meta is then managed by the system and should + * not be deleted by the caller. + * + * In case of failure, the method returns @c false and the + * caller is still responsible for deleting the object! + * + * @param p node coordinates + * @param meta pointer to @c NodeMetadata object + * @return @c true on success, false on failure + */ + bool setNodeMetadata(v3s16 p, NodeMetadata *meta); void removeNodeMetadata(v3s16 p); /* Node Timers These are basically coordinate wrappers to MapBlock */ - + NodeTimer getNodeTimer(v3s16 p); void setNodeTimer(v3s16 p, NodeTimer t); void removeNodeTimer(v3s16 p); @@ -322,23 +341,27 @@ class Map /*: public NodeContainer*/ /* Misc. */ - core::map *getSectorsPtr(){return &m_sectors;} + std::map *getSectorsPtr(){return &m_sectors;} /* Variables */ - + + void transforming_liquid_add(v3s16 p); + s32 transforming_liquid_size(); + protected: + friend class LuaVoxelManip; std::ostream &m_dout; // A bit deprecated, could be removed IGameDef *m_gamedef; - core::map m_event_receivers; + std::set m_event_receivers; - core::map m_sectors; + std::map m_sectors; - // Be sure to set this to NULL when the cached sector is deleted + // Be sure to set this to NULL when the cached sector is deleted MapSector *m_sector_cache; v2s16 m_sector_cache_p; @@ -377,16 +400,10 @@ class ServerMap : public Map /* Blocks are generated by using these and makeBlock(). */ - void initBlockMake(BlockMakeData *data, v3s16 blockpos); - MapBlock* finishBlockMake(BlockMakeData *data, - core::map &changed_blocks); - - // A non-threaded wrapper to the above - DEFUNCT -/* MapBlock * generateBlock( - v3s16 p, - core::map &modified_blocks - );*/ - + bool initBlockMake(BlockMakeData *data, v3s16 blockpos); + void finishBlockMake(BlockMakeData *data, + std::map &changed_blocks); + /* Get a block from somewhere. - Memory @@ -399,10 +416,21 @@ class ServerMap : public Map - Memory - Load from disk - Create blank filled with CONTENT_IGNORE - + */ MapBlock * emergeBlock(v3s16 p, bool create_blank=true); - + + /* + Try to get a block. + If it does not exist in memory, add it to the emerge queue. + - Memory + - Emerge Queue (deferred disk or generate) + */ + MapBlock *getBlockOrEmerge(v3s16 p3d); + + // Carries out any initialization necessary before block is sent + void prepareBlock(MapBlock *block); + // Helper for placing objects on ground level s16 findGroundLevel(v2s16 p2d); @@ -421,13 +449,8 @@ class ServerMap : public Map /* Database functions */ - // Create the database structure - void createDatabase(); // Verify we can read/write to the database void verifyDatabase(); - // Get an integer suitable for a block - static sqlite3_int64 getBlockAsInteger(const v3s16 pos); - static v3s16 getIntegerAsBlock(sqlite3_int64 i); // Returns true if the database file does not exist bool loadFromFolders(); @@ -437,34 +460,32 @@ class ServerMap : public Map void endSave(); void save(ModifiedState save_level); - //void loadAll(); - - void listAllLoadableBlocks(core::list &dst); - + void listAllLoadableBlocks(std::list &dst); + void listAllLoadedBlocks(std::list &dst); // Saves map seed and possibly other stuff void saveMapMeta(); void loadMapMeta(); - + /*void saveChunkMeta(); void loadChunkMeta();*/ - + // The sector mutex should be locked when calling most of these - + // This only saves sector-specific data such as the heightmap // (no MapBlocks) // DEPRECATED? Sectors have no metadata anymore. void saveSectorMeta(ServerMapSector *sector); MapSector* loadSectorMeta(std::string dirname, bool save_after_load); bool loadSectorMeta(v2s16 p2d); - + // Full load of a sector including all blocks. // returns true on success, false on failure. bool loadSectorFull(v2s16 p2d); // If sector is not found in memory, try to load it from disk. // Returns true if sector now resides in memory //bool deFlushSector(v2s16 p2d); - - void saveBlock(MapBlock *block); + + bool saveBlock(MapBlock *block); // This will generate a sector with getSector if not found. void loadBlock(std::string sectordir, std::string blockfile, MapSector *sector, bool save_after_load=false); MapBlock* loadBlock(v3s16 p); @@ -476,13 +497,13 @@ class ServerMap : public Map bool isSavingEnabled(){ return m_map_saving_enabled; } - u64 getSeed(){ return m_seed; } + u64 getSeed(); + s16 getWaterLevel(); - EmergeManager *m_emerge; private: - // Seed used for all kinds of randomness in generation - u64 m_seed; - + // Emerge manager + EmergeManager *m_emerge; + std::string m_savedir; bool m_map_saving_enabled; @@ -499,59 +520,42 @@ class ServerMap : public Map This is reset to false when written on disk. */ bool m_map_metadata_changed; - - /* - SQLite database and statements - */ - sqlite3 *m_database; - sqlite3_stmt *m_database_read; - sqlite3_stmt *m_database_write; - sqlite3_stmt *m_database_list; + Database *dbase; }; -class MapVoxelManipulator : public VoxelManipulator + +#define VMANIP_BLOCK_DATA_INEXIST 1 +#define VMANIP_BLOCK_CONTAINS_CIGNORE 2 + +class ManualMapVoxelManipulator : public VoxelManipulator { public: - MapVoxelManipulator(Map *map); - virtual ~MapVoxelManipulator(); - + ManualMapVoxelManipulator(Map *map); + virtual ~ManualMapVoxelManipulator(); + virtual void clear() { VoxelManipulator::clear(); m_loaded_blocks.clear(); } - virtual void emerge(VoxelArea a, s32 caller_id=-1); - - void blitBack(core::map & modified_blocks); - -protected: - Map *m_map; - /* - key = blockpos - value = block existed when loaded - */ - core::map m_loaded_blocks; -}; - -class ManualMapVoxelManipulator : public MapVoxelManipulator -{ -public: - ManualMapVoxelManipulator(Map *map); - virtual ~ManualMapVoxelManipulator(); - void setMap(Map *map) {m_map = map;} - - virtual void emerge(VoxelArea a, s32 caller_id=-1); - void initialEmerge(v3s16 blockpos_min, v3s16 blockpos_max); - + void initialEmerge(v3s16 blockpos_min, v3s16 blockpos_max, + bool load_if_inexistent = true); + // This is much faster with big chunks of generated data - void blitBackAll(core::map * modified_blocks); + void blitBackAll(std::map * modified_blocks); protected: bool m_create_area; + Map *m_map; + /* + key = blockpos + value = flags describing the block + */ + std::map m_loaded_blocks; }; #endif