X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fmap.h;h=3097d15b9fcc52549919ac1008d97118f55f4c21;hb=d5029958b9017ad89775bc4f68c4de3db603e618;hp=3c3fe9dafab9f2648fbee5c0642301bd05337666;hpb=07a759fdb8c3239aabb271cbd24e8b24b2dee435;p=oweals%2Fminetest.git diff --git a/src/map.h b/src/map.h index 3c3fe9daf..3097d15b9 100644 --- a/src/map.h +++ b/src/map.h @@ -1,18 +1,18 @@ /* Minetest-c55 -Copyright (C) 2010 celeron55, Perttu Ahola +Copyright (C) 2010-2011 celeron55, Perttu Ahola This program is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2 of the License, or +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. +GNU Lesser General Public License for more details. -You should have received a copy of the GNU General Public License along +You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ @@ -21,326 +21,193 @@ with this program; if not, write to the Free Software Foundation, Inc., #define MAP_HEADER #include +#include #include #include -#include - -#ifdef _WIN32 - #include - #define sleep_s(x) Sleep((x*1000)) -#else - #include - #define sleep_s(x) sleep(x) -#endif +#include -#include "common_irrlicht.h" -#include "heightmap.h" +#include "irrlichttypes_bloated.h" #include "mapnode.h" -#include "mapblock.h" -#include "mapsector.h" #include "constants.h" #include "voxel.h" +#include "mapgen.h" //for BlockMakeData and EmergeManager +#include "modifiedstate.h" +#include "util/container.h" +#include "nodetimer.h" -class Map; +extern "C" { + #include "sqlite3.h" +} + +class ClientMap; +class MapSector; +class ServerMapSector; +class MapBlock; +class NodeMetadata; +class IGameDef; +class IRollbackReportSink; -#if 0 -/* - A cache for short-term fast access to map data - NOTE: This doesn't really make anything more efficient - NOTE: Use VoxelManipulator, if possible - TODO: Get rid of this? - NOTE: CONFIRMED: THIS CACHE DOESN'T MAKE ANYTHING ANY FASTER +/* + MapEditEvent */ -class MapBlockPointerCache : public NodeContainer -{ -public: - MapBlockPointerCache(Map *map); - ~MapBlockPointerCache(); - virtual u16 nodeContainerId() const - { - return NODECONTAINER_ID_MAPBLOCKCACHE; - } +#define MAPTYPE_BASE 0 +#define MAPTYPE_SERVER 1 +#define MAPTYPE_CLIENT 2 - MapBlock * getBlockNoCreate(v3s16 p); +enum MapEditEventType{ + // Node added (changed from air or something else to something) + MEET_ADDNODE, + // Node removed (changed to air) + MEET_REMOVENODE, + // Node metadata of block changed (not knowing which node exactly) + // p stores block coordinate + MEET_BLOCK_NODE_METADATA_CHANGED, + // Anything else (modified_blocks are set unsent) + MEET_OTHER +}; - // virtual from NodeContainer - bool isValidPosition(v3s16 p) +struct MapEditEvent +{ + MapEditEventType type; + v3s16 p; + MapNode n; + core::map modified_blocks; + u16 already_known_by_peer; + + MapEditEvent(): + type(MEET_OTHER), + already_known_by_peer(0) { - v3s16 blockpos = getNodeBlockPos(p); - MapBlock *blockref; - try{ - blockref = getBlockNoCreate(blockpos); - } - catch(InvalidPositionException &e) - { - return false; - } - return true; } - // virtual from NodeContainer - MapNode getNode(v3s16 p) + MapEditEvent * clone() { - v3s16 blockpos = getNodeBlockPos(p); - MapBlock * blockref = getBlockNoCreate(blockpos); - v3s16 relpos = p - blockpos*MAP_BLOCKSIZE; - - return blockref->getNodeNoCheck(relpos); + 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); + } + return event; } - // virtual from NodeContainer - void setNode(v3s16 p, MapNode & n) + VoxelArea getArea() { - v3s16 blockpos = getNodeBlockPos(p); - MapBlock * block = getBlockNoCreate(blockpos); - v3s16 relpos = p - blockpos*MAP_BLOCKSIZE; - block->setNodeNoCheck(relpos, n); - m_modified_blocks[blockpos] = block; + switch(type){ + case MEET_ADDNODE: + return VoxelArea(p); + case MEET_REMOVENODE: + return VoxelArea(p); + case MEET_BLOCK_NODE_METADATA_CHANGED: + { + v3s16 np1 = p*MAP_BLOCKSIZE; + v3s16 np2 = np1 + v3s16(1,1,1)*MAP_BLOCKSIZE - v3s16(1,1,1); + return VoxelArea(np1, np2); + } + case MEET_OTHER: + { + VoxelArea a; + for(core::map::Iterator + i = modified_blocks.getIterator(); + i.atEnd()==false; i++) + { + v3s16 p = i.getNode()->getKey(); + v3s16 np1 = p*MAP_BLOCKSIZE; + v3s16 np2 = np1 + v3s16(1,1,1)*MAP_BLOCKSIZE - v3s16(1,1,1); + a.addPoint(np1); + a.addPoint(np2); + } + return a; + } + } + return VoxelArea(); } - - core::map m_modified_blocks; - -private: - Map *m_map; - core::map m_blocks; - - u32 m_from_cache_count; - u32 m_from_map_count; }; -#endif -class CacheLock +class MapEventReceiver { public: - CacheLock() - { - m_count = 0; - m_count_mutex.Init(); - m_cache_mutex.Init(); - m_waitcache_mutex.Init(); - } - - void cacheCreated() - { - //dstream<<"cacheCreated() begin"< 0); - - m_count--; - - // If this is the last one, release the cache lock - if(m_count == 0) - m_cache_mutex.Unlock(); - - //dstream<<"cacheRemoved() end"< m_sectors; - JMutex m_sector_mutex; - - v3f m_camera_position; - v3f m_camera_direction; - JMutex m_camera_mutex; - - // Be sure to set this to NULL when the cached sector is deleted - MapSector *m_sector_cache; - v2s16 m_sector_cache_p; - - WrapperHeightmap m_hwrapper; - public: - v3s16 drawoffset; // for drawbox() - - /* - Used by MapBlockPointerCache. - - waitCaches() can be called to remove all caches before continuing - */ - CacheLock m_blockcachelock; - - Map(std::ostream &dout); + Map(std::ostream &dout, IGameDef *gamedef); virtual ~Map(); - virtual u16 nodeContainerId() const + /*virtual u16 nodeContainerId() const { return NODECONTAINER_ID_MAP; - } + }*/ virtual s32 mapType() const { return MAPTYPE_BASE; } - + + /* + Drop (client) or delete (server) the map. + */ virtual void drop() { delete this; } - void updateCamera(v3f pos, v3f dir) - { - JMutexAutoLock lock(m_camera_mutex); - m_camera_position = pos; - m_camera_direction = dir; - } - - /*void StartUpdater() - { - updater.Start(); - } - - void StopUpdater() - { - updater.setRun(false); - while(updater.IsRunning()) - sleep_s(1); - } - - bool UpdaterIsRunning() - { - return updater.IsRunning(); - }*/ - - static core::aabbox3d getNodeBox(v3s16 p) - { - return core::aabbox3d( - (float)p.X * BS - 0.5*BS, - (float)p.Y * BS - 0.5*BS, - (float)p.Z * BS - 0.5*BS, - (float)p.X * BS + 0.5*BS, - (float)p.Y * BS + 0.5*BS, - (float)p.Z * BS + 0.5*BS - ); - } - - //bool sectorExists(v2s16 p); + void addEventReceiver(MapEventReceiver *event_receiver); + 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) + MapSector * getSectorNoGenerateNoEx(v2s16 p2d); + // On failure throws InvalidPositionException MapSector * getSectorNoGenerate(v2s16 p2d); + // Gets an existing sector or creates an empty one + //MapSector * getSectorCreate(v2s16 p2d); + /* This is overloaded by ClientMap and ServerMap to allow their differing fetch methods. */ - virtual MapSector * emergeSector(v2s16 p) = 0; - + virtual MapSector * emergeSector(v2s16 p){ return NULL; } + virtual MapSector * emergeSector(v2s16 p, + core::map &changed_blocks){ return NULL; } + // Returns InvalidPositionException if not found MapBlock * getBlockNoCreate(v3s16 p); // Returns NULL if not found MapBlock * getBlockNoCreateNoEx(v3s16 p); - // Returns InvalidPositionException if not found - f32 getGroundHeight(v2s16 p, bool generate=false); - void setGroundHeight(v2s16 p, f32 y, bool generate=false); + /* Server overrides */ + virtual MapBlock * emergeBlock(v3s16 p, bool allow_generate=true) + { return getBlockNoCreateNoEx(p); } // Returns InvalidPositionException if not found bool isNodeUnderground(v3s16 p); - // virtual from NodeContainer - bool isValidPosition(v3s16 p) - { - v3s16 blockpos = getNodeBlockPos(p); - MapBlock *blockref; - try{ - blockref = getBlockNoCreate(blockpos); - } - catch(InvalidPositionException &e) - { - return false; - } - return true; - /*v3s16 relpos = p - blockpos*MAP_BLOCKSIZE; - bool is_valid = blockref->isValidPosition(relpos); - return is_valid;*/ - } + bool isValidPosition(v3s16 p); - // virtual from NodeContainer // throws InvalidPositionException if not found - MapNode getNode(v3s16 p) - { - v3s16 blockpos = getNodeBlockPos(p); - MapBlock * blockref = getBlockNoCreate(blockpos); - v3s16 relpos = p - blockpos*MAP_BLOCKSIZE; + MapNode getNode(v3s16 p); - return blockref->getNodeNoCheck(relpos); - } - - // virtual from NodeContainer // throws InvalidPositionException if not found - void setNode(v3s16 p, MapNode & n) - { - v3s16 blockpos = getNodeBlockPos(p); - MapBlock * blockref = getBlockNoCreate(blockpos); - v3s16 relpos = p - blockpos*MAP_BLOCKSIZE; - blockref->setNodeNoCheck(relpos, n); - } - - /*MapNode getNodeGenerate(v3s16 p) - { - v3s16 blockpos = getNodeBlockPos(p); - MapBlock * blockref = getBlock(blockpos); - v3s16 relpos = p - blockpos*MAP_BLOCKSIZE; - - return blockref->getNode(relpos); - }*/ - - /*void setNodeGenerate(v3s16 p, MapNode & n) - { - v3s16 blockpos = getNodeBlockPos(p); - MapBlock * blockref = getBlock(blockpos); - v3s16 relpos = p - blockpos*MAP_BLOCKSIZE; - blockref->setNode(relpos, n); - }*/ + 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, @@ -379,82 +246,119 @@ public: core::map &modified_blocks); void removeNodeAndUpdate(v3s16 p, core::map &modified_blocks); - -#ifndef SERVER - void expireMeshes(bool only_daynight_diffed); - + /* - Updates the faces of the given block and blocks on the - leading edge. + Wrappers for the latter ones. + These emit events. + Return true if succeeded, false if not. */ - void updateMeshes(v3s16 blockpos, u32 daynight_ratio); -#endif - + bool addNodeWithEvent(v3s16 p, MapNode n); + bool removeNodeWithEvent(v3s16 p); + /* Takes the blocks at the edges into account */ - bool dayNightDiffed(v3s16 blockpos); + bool getDayNightDiff(v3s16 blockpos); //core::aabbox3d getDisplayedBlockArea(); //bool updateChangedVisibleArea(); + + // Call these before and after saving of many blocks + virtual void beginSave() {return;}; + virtual void endSave() {return;}; - virtual void save(bool only_changed){assert(0);}; + virtual void save(ModifiedState save_level){assert(0);}; + + // Server implements this. + // Client leaves it as no-op. + virtual void saveBlock(MapBlock *block){}; /* - Updates usage timers + Updates usage timers and unloads unused blocks and sectors. + Saves modified blocks before unloading on MAPTYPE_SERVER. */ - void timerUpdate(float dtime); - + void timerUpdate(float dtime, float unload_timeout, + core::list *unloaded_blocks=NULL); + + // Deletes sectors and their blocks from memory // Takes cache into account - // sector mutex should be locked when calling - void deleteSectors(core::list &list, bool only_blocks); - - // Returns count of deleted sectors - u32 deleteUnusedSectors(float timeout, bool only_blocks=false, + // If deleted sector is in sector cache, clears cache + void deleteSectors(core::list &list); + +#if 0 + /* + Unload unused data + = flush changed to disk and delete from memory, if usage timer of + block is more than timeout + */ + void unloadUnusedData(float timeout, core::list *deleted_blocks=NULL); +#endif - // For debug printing + // For debug printing. Prints "Map: ", "ServerMap: " or "ClientMap: " virtual void PrintInfo(std::ostream &out); -}; + + void transformLiquids(core::map & modified_blocks); -// Master heightmap parameters -struct HMParams -{ - HMParams() - { - blocksize = 64; - randmax = "constant 70.0"; - randfactor = "constant 0.6"; - base = "linear 0 80 0"; - } - s16 blocksize; - std::string randmax; - std::string randfactor; - std::string base; -}; + /* + Node metadata + These are basically coordinate wrappers to MapBlock + */ + + NodeMetadata* getNodeMetadata(v3s16 p); + void setNodeMetadata(v3s16 p, NodeMetadata *meta); + void removeNodeMetadata(v3s16 p); -// Map parameters -struct MapParams -{ - MapParams() - { - plants_amount = 1.0; - ravines_amount = 1.0; - //max_objects_in_block = 30; - } - float plants_amount; - float ravines_amount; - //u16 max_objects_in_block; + /* + Node Timers + These are basically coordinate wrappers to MapBlock + */ + + NodeTimer getNodeTimer(v3s16 p); + void setNodeTimer(v3s16 p, NodeTimer t); + void removeNodeTimer(v3s16 p); + + /* + Misc. + */ + core::map *getSectorsPtr(){return &m_sectors;} + + /* + Variables + */ + +protected: + + std::ostream &m_dout; // A bit deprecated, could be removed + + IGameDef *m_gamedef; + + core::map m_event_receivers; + + core::map m_sectors; + + // Be sure to set this to NULL when the cached sector is deleted + MapSector *m_sector_cache; + v2s16 m_sector_cache_p; + + // Queued transforming water nodes + UniqueQueue m_transforming_liquid; }; +/* + ServerMap + + This is the only map class that is able to generate map. +*/ + class ServerMap : public Map { public: /* savedir: directory to which map data should be saved */ - ServerMap(std::string savedir, HMParams hmp, MapParams mp); + ServerMap(std::string savedir, IGameDef *gamedef, EmergeManager *emerge); ~ServerMap(); s32 mapType() const @@ -463,58 +367,95 @@ public: } /* - Forcefully get a sector from somewhere + Get a sector from somewhere. + - Check memory + - Check disk (doesn't load blocks) + - Create blank one */ - MapSector * emergeSector(v2s16 p); + ServerMapSector * createSector(v2s16 p); + /* - Forcefully get a block from somewhere. + 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 + );*/ + + /* + Get a block from somewhere. + - Memory + - Create blank + */ + MapBlock * createBlock(v3s16 p); - Exceptions: - - InvalidPositionException: possible if only_from_disk==true - - changed_blocks: - - All already existing blocks that were modified are added. - - If found on disk, nothing will be added. - - If generated, the new block will not be included. - - lighting_invalidated_blocks: - - All blocks that have heavy-to-calculate lighting changes - are added. - - updateLighting() should be called for these. + /* + Forcefully get a block from somewhere. + - Memory + - Load from disk + - Create blank filled with CONTENT_IGNORE - - A block that is in changed_blocks may not be in - lighting_invalidated_blocks. */ - MapBlock * emergeBlock( - v3s16 p, - bool only_from_disk, - core::map &changed_blocks, - core::map &lighting_invalidated_blocks - ); - - void createDir(std::string path); - void createSaveDir(); - // returns something like "xxxxxxxx" - std::string getSectorSubDir(v2s16 pos); + MapBlock * emergeBlock(v3s16 p, bool create_blank=true); + + // Helper for placing objects on ground level + s16 findGroundLevel(v2s16 p2d); + + /* + Misc. helper functions for fiddling with directory and file + names when saving + */ + void createDirs(std::string path); // returns something like "map/sectors/xxxxxxxx" - std::string getSectorDir(v2s16 pos); - std::string createSectorDir(v2s16 pos); + std::string getSectorDir(v2s16 pos, int layout = 2); // dirname: final directory name v2s16 getSectorPos(std::string dirname); v3s16 getBlockPos(std::string sectordir, std::string blockfile); + static std::string getBlockFilename(v3s16 p); - void save(bool only_changed); - void loadAll(); - - void saveMasterHeightmap(); - void loadMasterHeightmap(); - + /* + 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(); + + // Call these before and after saving of blocks + void beginSave(); + void endSave(); + + void save(ModifiedState save_level); + //void loadAll(); + + void listAllLoadableBlocks(core::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); + 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. @@ -525,107 +466,49 @@ public: void saveBlock(MapBlock *block); // This will generate a sector with getSector if not found. - void loadBlock(std::string sectordir, std::string blockfile, MapSector *sector); - - // Gets from master heightmap - void getSectorCorners(v2s16 p2d, s16 *corners); + void loadBlock(std::string sectordir, std::string blockfile, MapSector *sector, bool save_after_load=false); + MapBlock* loadBlock(v3s16 p); + // Database version + void loadBlock(std::string *blob, v3s16 p3d, MapSector *sector, bool save_after_load=false); // For debug printing virtual void PrintInfo(std::ostream &out); -private: - UnlimitedHeightmap *m_heightmap; - MapParams m_params; + bool isSavingEnabled(){ return m_map_saving_enabled; } + u64 getSeed(){ return m_seed; } + + EmergeManager *m_emerge; +private: + // Seed used for all kinds of randomness in generation + u64 m_seed; + std::string m_savedir; bool m_map_saving_enabled; -}; - -#ifndef SERVER - -class Client; -class ClientMap : public Map, public scene::ISceneNode -{ -public: - ClientMap( - Client *client, - JMutex &range_mutex, - s16 &viewing_range_nodes, - bool &viewing_range_all, - scene::ISceneNode* parent, - scene::ISceneManager* mgr, - s32 id - ); - - ~ClientMap(); - - s32 mapType() const - { - return MAPTYPE_CLIENT; - } - - void drop() - { - ISceneNode::drop(); - } - - /* - Forcefully get a sector from somewhere - */ - MapSector * emergeSector(v2s16 p); - - void deSerializeSector(v2s16 p2d, std::istream &is); +#if 0 + // Chunk size in MapSectors + // If 0, chunks are disabled. + s16 m_chunksize; + // Chunks + core::map m_chunks; +#endif /* - ISceneNode methods + Metadata is re-written on disk only if this is true. + This is reset to false when written on disk. */ - - virtual void OnRegisterSceneNode(); - - virtual void render() - { - video::IVideoDriver* driver = SceneManager->getVideoDriver(); - driver->setTransform(video::ETS_WORLD, AbsoluteTransformation); - renderMap(driver, SceneManager->getSceneNodeRenderPass()); - } + bool m_map_metadata_changed; - virtual const core::aabbox3d& getBoundingBox() const - { - return m_box; - } - - void renderMap(video::IVideoDriver* driver, s32 pass); - /* - Methods for setting temporary modifications to nodes for - drawing. - Return value is position of changed block. + SQLite database and statements */ - v3s16 setTempMod(v3s16 p, NodeMod mod); - v3s16 clearTempMod(v3s16 p); - // Efficient implementation needs a cache of TempMods - //void clearTempMods(); - - // For debug printing - virtual void PrintInfo(std::ostream &out); - -private: - Client *m_client; - - core::aabbox3d m_box; - - // This is the master heightmap mesh - scene::SMesh *mesh; - JMutex mesh_mutex; - - JMutex &m_range_mutex; - s16 &m_viewing_range_nodes; - bool &m_viewing_range_all; + sqlite3 *m_database; + sqlite3_stmt *m_database_read; + sqlite3_stmt *m_database_write; + sqlite3_stmt *m_database_list; }; -#endif - class MapVoxelManipulator : public VoxelManipulator { public: @@ -642,16 +525,34 @@ public: void blitBack(core::map & modified_blocks); -private: +protected: Map *m_map; /* - NOTE: This might be used or not - bool is dummy value - SUGG: How 'bout an another VoxelManipulator for storing the - information about which block is loaded? + 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); + + // This is much faster with big chunks of generated data + void blitBackAll(core::map * modified_blocks); + +protected: + bool m_create_area; +}; + #endif