/* Minetest-c55 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 (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. You should have received a copy of the GNU 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. */ #ifndef MAP_HEADER #define MAP_HEADER #include #include #include #include #include #include "common_irrlicht.h" #include "mapnode.h" #include "mapblock_nodemod.h" #include "constants.h" #include "voxel.h" #include "utility.h" // Needed for UniqueQueue, a member of Map #include "modifiedstate.h" extern "C" { #include "sqlite3.h" } class MapSector; class ServerMapSector; class ClientMapSector; class MapBlock; class NodeMetadata; class IGameDef; namespace mapgen{ struct BlockMakeData; }; /* MapEditEvent */ #define MAPTYPE_BASE 0 #define MAPTYPE_SERVER 1 #define MAPTYPE_CLIENT 2 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 }; 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) { } 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); } return event; } }; class MapEventReceiver { public: // event shall be deleted by caller after the call. virtual void onMapEditEvent(MapEditEvent *event) = 0; }; class Map /*: public NodeContainer*/ { public: Map(std::ostream &dout, IGameDef *gamedef); virtual ~Map(); /*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 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){ 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) { 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); 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); /* These handle lighting but not faces. */ void addNodeAndUpdate(v3s16 p, MapNode n, core::map but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. 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. */ #include "test.h" #include "gamedef.h" #include "nodedef.h" #include "content_mapnode.h" class TestMapNode : public TestBase { public: TestMapNode() { TestManager::registerTestModule(this); } const char *getName() { return "TestMapNode"; } void runTests(IGameDef *gamedef); void testNodeProperties(const NodeDefManager *nodedef); }; static TestMapNode g_test_instance; void TestMapNode::runTests(IGameDef *gamedef) { TEST(testNodeProperties, gamedef->getNodeDefManager()); } //////////////////////////////////////////////////////////////////////////////// void TestMapNode::testNodeProperties(const NodeDefManager *nodedef) { MapNode n(CONTENT_AIR); UASSERT(n.getContent() == CONTENT_AIR); UASSERT(n.getLight(LIGHTBANK_DAY, nodedef) == 0); UASSERT(n.getLight(LIGHTBANK_NIGHT, nodedef) == 0); // Transparency n.setContent(CONTENT_AIR); UASSERT(nodedef->get(n).light_propagates == true); } 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); // 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); // 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); bool isSavingEnabled(){ return m_map_saving_enabled; } u64 getSeed(){ return m_seed; } private: // Seed used for all kinds of randomness in generation u64 m_seed; std::string m_savedir; bool m_map_saving_enabled; #if 0 // Chunk size in MapSectors // If 0, chunks are disabled. s16 m_chunksize; // Chunks core::map m_chunks; #endif /* 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; }; /* ClientMap stuff */ #ifndef SERVER struct MapDrawControl { MapDrawControl(): range_all(false), wanted_range(50), wanted_max_blocks(0), wanted_min_range(0), blocks_drawn(0), blocks_would_have_drawn(0) { } // Overrides limits by drawing everything bool range_all; // Wanted drawing range float wanted_range; // Maximum number of blocks to draw u32 wanted_max_blocks; // Blocks in this range are drawn regardless of number of blocks drawn float wanted_min_range; // Number of blocks rendered is written here by the renderer u32 blocks_drawn; // Number of blocks that would have been drawn in wanted_range u32 blocks_would_have_drawn; }; class Client; class ITextureSource; /* ClientMap This is the only map class that is able to render itself on screen. */ class ClientMap : public Map, public scene::ISceneNode { public: ClientMap( Client *client, IGameDef *gamedef, MapDrawControl &control, scene::ISceneNode* parent, scene::ISceneManager* mgr, s32 id ); ~ClientMap(); s32 mapType() const { return MAPTYPE_CLIENT; } void drop() { ISceneNode::drop(); } void updateCamera(v3f pos, v3f dir, f32 fov) { JMutexAutoLock lock(m_camera_mutex); m_camera_position = pos; m_camera_direction = dir; m_camera_fov = fov; } /* Forcefully get a sector from somewhere */ MapSector * emergeSector(v2s16 p); //void deSerializeSector(v2s16 p2d, std::istream &is); /* ISceneNode methods */ virtual void OnRegisterSceneNode(); virtual void render() { video::IVideoDriver* driver = SceneManager->getVideoDriver(); driver->setTransform(video::ETS_WORLD, AbsoluteTransformation); renderMap(driver, SceneManager->getSceneNodeRenderPass()); } virtual const core::aabbox3d& getBoundingBox() const { return m_box; } void renderMap(video::IVideoDriver* driver, s32 pass); void renderPostFx(); /* Methods for setting temporary modifications to nodes for drawing. Returns true if something changed. All blocks whose mesh could have been changed are inserted to affected_blocks. */ bool setTempMod(v3s16 p, NodeMod mod, core::map *affected_blocks=NULL); bool clearTempMod(v3s16 p, core::map *affected_blocks=NULL); // Efficient implementation needs a cache of TempMods //void clearTempMods(); void expireMeshes(bool only_daynight_diffed); /* Update the faces of the given block and blocks on the leading edge, without threading. Rarely used. */ void updateMeshes(v3s16 blockpos, u32 daynight_ratio); // Update meshes that touch the node //void updateNodeMeshes(v3s16 nodepos, u32 daynight_ratio); // For debug printing virtual void PrintInfo(std::ostream &out); // Check if sector was drawn on last render() bool sectorWasDrawn(v2s16 p) { return (m_last_drawn_sectors.find(p) != NULL); } private: Client *m_client; core::aabbox3d m_box; // This is the master heightmap mesh //scene::SMesh *mesh; //JMutex mesh_mutex; MapDrawControl &m_control; v3f m_camera_position; v3f m_camera_direction; f32 m_camera_fov; JMutex m_camera_mutex; core::map m_last_drawn_sectors; }; #endif class MapVoxelManipulator : public VoxelManipulator { public: MapVoxelManipulator(Map *map); virtual ~MapVoxelManipulator(); 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); // This is much faster with big chunks of generated data void blitBackAll(core::map * modified_blocks); protected: bool m_create_area; }; #endif