X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fmap.h;h=7ef34b2792c72638128e49d87ca1d4b90bc44497;hb=242c9bc36e490daee0fbe74da1feae3fefa76579;hp=a6a4bee8ed6bd230d7176d3ff76fc45a03aefa3f;hpb=037b2591971d752e67fa7d47095b996b3f56da5a;p=dragonfireclient.git diff --git a/src/map.h b/src/map.h index a6a4bee8e..7ef34b279 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 @@ -17,36 +17,36 @@ with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#ifndef MAP_HEADER -#define MAP_HEADER +#pragma once -#include -#include -#include #include #include +#include +#include +#include -#include "common_irrlicht.h" +#include "irrlichttypes_bloated.h" #include "mapnode.h" #include "constants.h" #include "voxel.h" -#include "utility.h" // Needed for UniqueQueue, a member of Map #include "modifiedstate.h" +#include "util/container.h" +#include "nodetimer.h" +#include "map_settings_manager.h" +#include "debug.h" -extern "C" { - #include "sqlite3.h" -} - +class Settings; +class MapDatabase; class ClientMap; class MapSector; class ServerMapSector; class MapBlock; class NodeMetadata; class IGameDef; - -namespace mapgen{ - struct BlockMakeData; -}; +class IRollbackManager; +class EmergeManager; +class ServerEnvironment; +struct BlockMakeData; /* MapEditEvent @@ -61,8 +61,9 @@ enum MapEditEventType{ MEET_ADDNODE, // Node removed (changed to air) MEET_REMOVENODE, - // Node metadata of block changed (not knowing which node exactly) - // p stores block coordinate + // Node swapped (changed without metadata change) + MEET_SWAPNODE, + // Node metadata changed MEET_BLOCK_NODE_METADATA_CHANGED, // Anything else (modified_blocks are set unsent) MEET_OTHER @@ -70,32 +71,22 @@ enum MapEditEventType{ struct MapEditEvent { - MapEditEventType type; + MapEditEventType type = MEET_OTHER; v3s16 p; - MapNode n; - core::map modified_blocks; - u16 already_known_by_peer; + MapNode n = CONTENT_AIR; + std::set modified_blocks; + bool is_private_change = false; + + MapEditEvent() = default; - MapEditEvent(): - type(MEET_OTHER), - 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; + event->is_private_change = is_private_change; return event; } @@ -106,6 +97,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 +108,7 @@ struct MapEditEvent case MEET_OTHER: { VoxelArea a; - for(core::map::Iterator - i = modified_blocks.getIterator(); - i.atEnd()==false; i++) - { - v3s16 p = i.getNode()->getKey(); + for (v3s16 p : modified_blocks) { v3s16 np1 = p*MAP_BLOCKSIZE; v3s16 np2 = np1 + v3s16(1,1,1)*MAP_BLOCKSIZE - v3s16(1,1,1); a.addPoint(np1); @@ -145,17 +134,13 @@ class Map /*: public NodeContainer*/ Map(std::ostream &dout, IGameDef *gamedef); virtual ~Map(); - - /*virtual u16 nodeContainerId() const - { - return NODECONTAINER_ID_MAP; - }*/ + DISABLE_CLASS_COPY(Map); virtual s32 mapType() const { return MAPTYPE_BASE; } - + /* Drop (client) or delete (server) the map. */ @@ -183,158 +168,158 @@ class Map /*: public NodeContainer*/ their differing fetch methods. */ 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); - + /* Server overrides */ - virtual MapBlock * emergeBlock(v3s16 p, bool allow_generate=true) + virtual MapBlock * emergeBlock(v3s16 p, bool create_blank=true) { return getBlockNoCreateNoEx(p); } + inline const NodeDefManager * getNodeDefManager() { return m_nodedef; } + // 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); - - void unLightNeighbors(enum LightBank bank, - v3s16 pos, u8 lightwas, - core::map & light_sources, - core::map & modified_blocks); - - void spreadLight(enum LightBank bank, - core::map & from_nodes, - core::map & modified_blocks); - - void lightNeighbors(enum LightBank bank, - v3s16 pos, - core::map & modified_blocks); - - v3s16 getBrightestNeighbour(enum LightBank bank, v3s16 p); - - s16 propagateSunlight(v3s16 start, - core::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); - + // If is_valid_position is not NULL then this will be set to true if the + // position is valid, otherwise false + MapNode getNodeNoEx(v3s16 p, bool *is_valid_position = NULL); + /* 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 - */ - bool getDayNightDiff(v3s16 blockpos); - //core::aabbox3d getDisplayedBlockArea(); + // Call these before and after saving of many blocks + virtual void beginSave() {} + virtual void endSave() {} - //bool updateChangedVisibleArea(); + virtual void save(ModifiedState save_level) { FATAL_ERROR("FIXME"); } - // 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){}; + // Server implements these. + // Client leaves them as no-op. + virtual bool saveBlock(MapBlock *block) { return false; } + virtual bool deleteBlock(v3s16 blockpos) { 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); - - // 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 timerUpdate(float dtime, float unload_timeout, u32 max_loaded_blocks, + std::vector *unloaded_blocks=NULL); -#if 0 /* - Unload unused data - = flush changed to disk and delete from memory, if usage timer of - block is more than timeout + Unloads all blocks with a zero refCount(). + Saves modified blocks before unloading on MAPTYPE_SERVER. */ - void unloadUnusedData(float timeout, - core::list *deleted_blocks=NULL); -#endif + void unloadUnreferencedBlocks(std::vector *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(std::vector &list); // 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, + ServerEnvironment *env); /* Node metadata These are basically coordinate wrappers to MapBlock */ - - NodeMetadata* getNodeMetadata(v3s16 p); - void setNodeMetadata(v3s16 p, NodeMetadata *meta); + + std::vector findNodesWithMetadata(v3s16 p1, v3s16 p2); + NodeMetadata *getNodeMetadata(v3s16 p); + + /** + * 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(const NodeTimer &t); + void removeNodeTimer(v3s16 p); + /* Misc. */ - core::map *getSectorsPtr(){return &m_sectors;} + std::map *getSectorsPtr(){return &m_sectors;} /* Variables */ - + + void transforming_liquid_add(v3s16 p); + + bool isBlockOccluded(MapBlock *block, v3s16 cam_pos_nodes); protected: + friend class LuaVoxelManip; std::ostream &m_dout; // A bit deprecated, could be removed IGameDef *m_gamedef; - core::map m_event_receivers; - - core::map m_sectors; + std::set m_event_receivers; + + std::map m_sectors; - // Be sure to set this to NULL when the cached sector is deleted - MapSector *m_sector_cache; + // Be sure to set this to NULL when the cached sector is deleted + MapSector *m_sector_cache = nullptr; v2s16 m_sector_cache_p; // Queued transforming water nodes UniqueQueue m_transforming_liquid; + + // This stores the properties of the nodes on the map. + const NodeDefManager *m_nodedef; + + bool isOccluded(v3s16 p0, v3s16 p1, float step, float stepfac, + float start_off, float end_off, u32 needed_count); + +private: + f32 m_transforming_liquid_loop_count_multiplier = 1.0f; + u32 m_unprocessed_count = 0; + u64 m_inc_trending_up_start_time = 0; // milliseconds + bool m_queue_size_timer_started = false; }; /* @@ -349,7 +334,7 @@ class ServerMap : public Map /* savedir: directory to which map data should be saved */ - ServerMap(std::string savedir, IGameDef *gamedef); + ServerMap(const std::string &savedir, IGameDef *gamedef, EmergeManager *emerge); ~ServerMap(); s32 mapType() const @@ -363,36 +348,40 @@ class ServerMap : public Map - Check disk (doesn't load blocks) - Create blank one */ - ServerMapSector * createSector(v2s16 p); + MapSector *createSector(v2s16 p); /* Blocks are generated by using these and makeBlock(). */ - void initBlockMake(mapgen::BlockMakeData *data, v3s16 blockpos); - MapBlock* finishBlockMake(mapgen::BlockMakeData *data, - core::map &changed_blocks); - - // A non-threaded wrapper to the above - MapBlock * generateBlock( - v3s16 p, - core::map &modified_blocks - ); - + bool blockpos_over_mapgen_limit(v3s16 p); + bool initBlockMake(v3s16 blockpos, BlockMakeData *data); + void finishBlockMake(BlockMakeData *data, + std::map *changed_blocks); + /* Get a block from somewhere. - Memory - Create blank */ - MapBlock * createBlock(v3s16 p); + MapBlock *createBlock(v3s16 p); /* Forcefully get a block from somewhere. - Memory - Load from disk - - Generate + - 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 * emergeBlock(v3s16 p, bool allow_generate=true); - + MapBlock *getBlockOrEmerge(v3s16 p3d); + // Helper for placing objects on ground level s16 findGroundLevel(v2s16 p2d); @@ -404,20 +393,14 @@ class ServerMap : public Map // returns something like "map/sectors/xxxxxxxx" 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); + v2s16 getSectorPos(const std::string &dirname); + v3s16 getBlockPos(const std::string §ordir, const std::string &blockfile); static std::string getBlockFilename(v3s16 p); /* 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); + static MapDatabase *createDatabase(const std::string &name, const std::string &savedir, Settings &conf); // Returns true if the database file does not exist bool loadFromFolders(); @@ -427,51 +410,48 @@ class ServerMap : public Map 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, 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); + void listAllLoadableBlocks(std::vector &dst); + void listAllLoadedBlocks(std::vector &dst); + + MapgenParams *getMapgenParams(); + + bool saveBlock(MapBlock *block); + static bool saveBlock(MapBlock *block, MapDatabase *db); // 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); + void loadBlock(const std::string §ordir, const 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); + bool deleteBlock(v3s16 blockpos); + + void updateVManip(v3s16 pos); + // For debug printing virtual void PrintInfo(std::ostream &out); bool isSavingEnabled(){ return m_map_saving_enabled; } - u64 getSeed(){ return m_seed; } + u64 getSeed(); + s16 getWaterLevel(); + + /*! + * Fixes lighting in one map block. + * May modify other blocks as well, as light can spread + * out of the specified block. + * Returns false if the block is not generated (so nothing + * changed), true otherwise. + */ + bool repairBlockLight(v3s16 blockpos, + std::map *modified_blocks); + + MapSettingsManager settings_mgr; 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; @@ -487,61 +467,41 @@ class ServerMap : public Map Metadata is re-written on disk only if this is true. 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; + bool m_map_metadata_changed = true; + MapDatabase *dbase = nullptr; + MapDatabase *dbase_ro = nullptr; }; -class MapVoxelManipulator : public VoxelManipulator + +#define VMANIP_BLOCK_DATA_INEXIST 1 +#define VMANIP_BLOCK_CONTAINS_CIGNORE 2 + +class MMVManip : public VoxelManipulator { public: - MapVoxelManipulator(Map *map); - virtual ~MapVoxelManipulator(); - + MMVManip(Map *map); + virtual ~MMVManip() = default; + virtual void clear() { VoxelManipulator::clear(); m_loaded_blocks.clear(); } - virtual void emerge(VoxelArea a, s32 caller_id=-1); + void initialEmerge(v3s16 blockpos_min, v3s16 blockpos_max, + bool load_if_inexistent = true); - void blitBack(core::map & modified_blocks); + // This is much faster with big chunks of generated data + void blitBackAll(std::map * modified_blocks, + bool overwrite_generated = true); + + bool m_is_dirty = false; protected: Map *m_map; /* key = blockpos - value = block existed when loaded + value = flags describing the block */ - core::map m_loaded_blocks; + std::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 -