src/map.h

   1 /*
   2 Minetest-c55
   3 Copyright (C) 2010-2011 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 General Public License as published by
   7 the Free Software Foundation; either version 2 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 General Public License for more details.
  14
  15 You should have received a copy of the GNU 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 <jmutex.h>
  24 #include <jmutexautolock.h>
  25 #include <jthread.h>
  26 #include <iostream>
  27 #include <sstream>
  28
  29 #include "common_irrlicht.h"
  30 #include "mapnode.h"
  31 #include "mapblock_nodemod.h"
  32 #include "constants.h"
  33 #include "voxel.h"
  34
  35 extern "C" {
  36         #include "sqlite3.h"
  37 }
  38
  39 class MapSector;
  40 class ServerMapSector;
  41 class ClientMapSector;
  42 class MapBlock;
  43 class NodeMetadata;
  44
  45 namespace mapgen{
  46         struct BlockMakeData;
  47 };
  48
  49 /*
  50         MapEditEvent
  51 */
  52
  53 #define MAPTYPE_BASE 0
  54 #define MAPTYPE_SERVER 1
  55 #define MAPTYPE_CLIENT 2
  56
  57 enum MapEditEventType{
  58         // Node added (changed from air or something else to something)
  59         MEET_ADDNODE,
  60         // Node removed (changed to air)
  61         MEET_REMOVENODE,
  62         // Node metadata of block changed (not knowing which node exactly)
  63         // p stores block coordinate
  64         MEET_BLOCK_NODE_METADATA_CHANGED,
  65         // Anything else (modified_blocks are set unsent)
  66         MEET_OTHER
  67 };
  68
  69 struct MapEditEvent
  70 {
  71         MapEditEventType type;
  72         v3s16 p;
  73         MapNode n;
  74         core::map<v3s16, bool> modified_blocks;
  75         u16 already_known_by_peer;
  76
  77         MapEditEvent():
  78                 type(MEET_OTHER),
  79                 already_known_by_peer(0)
  80         {
  81         }
  82
  83         MapEditEvent * clone()
  84         {
  85                 MapEditEvent *event = new MapEditEvent();
  86                 event->type = type;
  87                 event->p = p;
  88                 event->n = n;
  89                 for(core::map<v3s16, bool>::Iterator
  90                                 i = modified_blocks.getIterator();
  91                                 i.atEnd()==false; i++)
  92                 {
  93                         v3s16 p = i.getNode()->getKey();
  94                         bool v = i.getNode()->getValue();
  95                         event->modified_blocks.insert(p, v);
  96                 }
  97                 return event;
  98         }
  99 };
 100
 101 class MapEventReceiver
 102 {
 103 public:
 104         // event shall be deleted by caller after the call.
 105         virtual void onMapEditEvent(MapEditEvent *event) = 0;
 106 };
 107
 108 class Map /*: public NodeContainer*/
 109 {
 110 public:
 111
 112         Map(std::ostream &dout);
 113         virtual ~Map();
 114
 115         /*virtual u16 nodeContainerId() const
 116         {
 117                 return NODECONTAINER_ID_MAP;
 118         }*/
 119
 120         virtual s32 mapType() const
 121         {
 122                 return MAPTYPE_BASE;
 123         }
 124
 125         /*
 126                 Drop (client) or delete (server) the map.
 127         */
 128         virtual void drop()
 129         {
 130                 delete this;
 131         }
 132
 133         void addEventReceiver(MapEventReceiver *event_receiver);
 134         void removeEventReceiver(MapEventReceiver *event_receiver);
 135         // event shall be deleted by caller after the call.
 136         void dispatchEvent(MapEditEvent *event);
 137
 138         // On failure returns NULL
 139         MapSector * getSectorNoGenerateNoExNoLock(v2s16 p2d);
 140         // Same as the above (there exists no lock anymore)
 141         MapSector * getSectorNoGenerateNoEx(v2s16 p2d);
 142         // On failure throws InvalidPositionException
 143         MapSector * getSectorNoGenerate(v2s16 p2d);
 144         // Gets an existing sector or creates an empty one
 145         //MapSector * getSectorCreate(v2s16 p2d);
 146
 147         /*
 148                 This is overloaded by ClientMap and ServerMap to allow
 149                 their differing fetch methods.
 150         */
 151         virtual MapSector * emergeSector(v2s16 p){ return NULL; }
 152         virtual MapSector * emergeSector(v2s16 p,
 153                         core::map<v3s16, MapBlock*> &changed_blocks){ return NULL; }
 154
 155         // Returns InvalidPositionException if not found
 156         MapBlock * getBlockNoCreate(v3s16 p);
 157         // Returns NULL if not found
 158         MapBlock * getBlockNoCreateNoEx(v3s16 p);
 159
 160         /* Server overrides */
 161         virtual MapBlock * emergeBlock(v3s16 p, bool allow_generate=true)
 162         { return getBlockNoCreateNoEx(p); }
 163
 164         // Returns InvalidPositionException if not found
 165         bool isNodeUnderground(v3s16 p);
 166
 167         bool isValidPosition(v3s16 p);
 168
 169         // throws InvalidPositionException if not found
 170         MapNode getNode(v3s16 p);
 171
 172         // throws InvalidPositionException if not found
 173         void setNode(v3s16 p, MapNode & n);
 174
 175         // Returns a CONTENT_IGNORE node if not found
 176         MapNode getNodeNoEx(v3s16 p);
 177
 178         void unspreadLight(enum LightBank bank,
 179                         core::map<v3s16, u8> & from_nodes,
 180                         core::map<v3s16, bool> & light_sources,
 181                         core::map<v3s16, MapBlock*> & modified_blocks);
 182
 183         void unLightNeighbors(enum LightBank bank,
 184                         v3s16 pos, u8 lightwas,
 185                         core::map<v3s16, bool> & light_sources,
 186                         core::map<v3s16, MapBlock*> & modified_blocks);
 187
 188         void spreadLight(enum LightBank bank,
 189                         core::map<v3s16, bool> & from_nodes,
 190                         core::map<v3s16, MapBlock*> & modified_blocks);
 191
 192         void lightNeighbors(enum LightBank bank,
 193                         v3s16 pos,
 194                         core::map<v3s16, MapBlock*> & modified_blocks);
 195
 196         v3s16 getBrightestNeighbour(enum LightBank bank, v3s16 p);
 197
 198         s16 propagateSunlight(v3s16 start,
 199                         core::map<v3s16, MapBlock*> & modified_blocks);
 200
 201         void updateLighting(enum LightBank bank,
 202                         core::map<v3s16, MapBlock*>  & a_blocks,
 203                         core::map<v3s16, MapBlock*> & modified_blocks);
 204
 205         void updateLighting(core::map<v3s16, MapBlock*>  & a_blocks,
 206                         core::map<v3s16, MapBlock*> & modified_blocks);
 207
 208         /*
 209                 These handle lighting but not faces.
 210         */
 211         void addNodeAndUpdate(v3s16 p, MapNode n,
 212                         core::map<v3s16, MapBlock*> &modified_blocks, std::string &player_name);
 213         void removeNodeAndUpdate(v3s16 p,
 214                         core::map<v3s16, MapBlock*> &modified_blocks);
 215
 216         /*
 217                 Wrappers for the latter ones.
 218                 These emit events.
 219                 Return true if succeeded, false if not.
 220         */
 221         bool addNodeWithEvent(v3s16 p, MapNode n);
 222         bool removeNodeWithEvent(v3s16 p);
 223
 224         /*
 225                 Takes the blocks at the edges into account
 226         */
 227         bool dayNightDiffed(v3s16 blockpos);
 228
 229         //core::aabbox3d<s16> getDisplayedBlockArea();
 230
 231         //bool updateChangedVisibleArea();
 232
 233         // Call these before and after saving of many blocks
 234         virtual void beginSave() {return;};
 235         virtual void endSave() {return;};
 236
 237         virtual void save(bool only_changed){assert(0);};
 238
 239         // Server implements this.
 240         // Client leaves it as no-op.
 241         virtual void saveBlock(MapBlock *block){};
 242
 243         /*
 244                 Updates usage timers and unloads unused blocks and sectors.
 245                 Saves modified blocks before unloading on MAPTYPE_SERVER.
 246         */
 247         void timerUpdate(float dtime, float unload_timeout,
 248                         core::list<v3s16> *unloaded_blocks=NULL);
 249
 250         // Deletes sectors and their blocks from memory
 251         // Takes cache into account
 252         // If deleted sector is in sector cache, clears cache
 253         void deleteSectors(core::list<v2s16> &list);
 254
 255 #if 0
 256         /*
 257                 Unload unused data
 258                 = flush changed to disk and delete from memory, if usage timer of
 259                   block is more than timeout
 260         */
 261         void unloadUnusedData(float timeout,
 262                         core::list<v3s16> *deleted_blocks=NULL);
 263 #endif
 264
 265         // For debug printing. Prints "Map: ", "ServerMap: " or "ClientMap: "
 266         virtual void PrintInfo(std::ostream &out);
 267
 268         void transformLiquids(core::map<v3s16, MapBlock*> & modified_blocks);
 269
 270         /*
 271                 Node metadata
 272                 These are basically coordinate wrappers to MapBlock
 273         */
 274
 275         NodeMetadata* getNodeMetadata(v3s16 p);
 276         void setNodeMetadata(v3s16 p, NodeMetadata *meta);
 277         void removeNodeMetadata(v3s16 p);
 278         void nodeMetadataStep(float dtime,
 279                         core::map<v3s16, MapBlock*> &changed_blocks);
 280
 281         /*
 282                 Misc.
 283         */
 284         core::map<v2s16, MapSector*> *getSectorsPtr(){return &m_sectors;}
 285
 286         /*
 287                 Variables
 288         */
 289
 290 protected:
 291
 292         std::ostream &m_dout;
 293
 294         core::map<MapEventReceiver*, bool> m_event_receivers;
 295
 296         core::map<v2s16, MapSector*> m_sectors;
 297
 298         // Be sure to set this to NULL when the cached sector is deleted
 299         MapSector *m_sector_cache;
 300         v2s16 m_sector_cache_p;
 301
 302         // Queued transforming water nodes
 303         UniqueQueue<v3s16> m_transforming_liquid;
 304 };
 305
 306 /*
 307         ServerMap
 308
 309         This is the only map class that is able to generate map.
 310 */
 311
 312 class ServerMap : public Map
 313 {
 314 public:
 315         /*
 316                 savedir: directory to which map data should be saved
 317         */
 318         ServerMap(std::string savedir);
 319         ~ServerMap();
 320
 321         s32 mapType() const
 322         {
 323                 return MAPTYPE_SERVER;
 324         }
 325
 326         /*
 327                 Get a sector from somewhere.
 328                 - Check memory
 329                 - Check disk (doesn't load blocks)
 330                 - Create blank one
 331         */
 332         ServerMapSector * createSector(v2s16 p);
 333
 334         /*
 335                 Blocks are generated by using these and makeBlock().
 336         */
 337         void initBlockMake(mapgen::BlockMakeData *data, v3s16 blockpos);
 338         MapBlock* finishBlockMake(mapgen::BlockMakeData *data,
 339                         core::map<v3s16, MapBlock*> &changed_blocks);
 340
 341         // A non-threaded wrapper to the above
 342         MapBlock * generateBlock(
 343                         v3s16 p,
 344                         core::map<v3s16, MapBlock*> &modified_blocks
 345         );
 346
 347         /*
 348                 Get a block from somewhere.
 349                 - Memory
 350                 - Create blank
 351         */
 352         MapBlock * createBlock(v3s16 p);
 353
 354         /*
 355                 Forcefully get a block from somewhere.
 356                 - Memory
 357                 - Load from disk
 358                 - Generate
 359         */
 360         MapBlock * emergeBlock(v3s16 p, bool allow_generate=true);
 361
 362         // Helper for placing objects on ground level
 363         s16 findGroundLevel(v2s16 p2d);
 364
 365         /*
 366                 Misc. helper functions for fiddling with directory and file
 367                 names when saving
 368         */
 369         void createDirs(std::string path);
 370         // returns something like "map/sectors/xxxxxxxx"
 371         std::string getSectorDir(v2s16 pos, int layout = 2);
 372         // dirname: final directory name
 373         v2s16 getSectorPos(std::string dirname);
 374         v3s16 getBlockPos(std::string sectordir, std::string blockfile);
 375         static std::string getBlockFilename(v3s16 p);
 376
 377         /*
 378                 Database functions
 379         */
 380         // Create the database structure
 381         void createDatabase();
 382         // Verify we can read/write to the database
 383         void verifyDatabase();
 384         // Get an integer suitable for a block
 385         static sqlite3_int64 getBlockAsInteger(const v3s16 pos);
 386
 387         // Returns true if the database file does not exist
 388         bool loadFromFolders();
 389
 390         // Call these before and after saving of blocks
 391         void beginSave();
 392         void endSave();
 393
 394         void save(bool only_changed);
 395         //void loadAll();
 396
 397         // Saves map seed and possibly other stuff
 398         void saveMapMeta();
 399         void loadMapMeta();
 400
 401         /*void saveChunkMeta();
 402         void loadChunkMeta();*/
 403
 404         // The sector mutex should be locked when calling most of these
 405
 406         // This only saves sector-specific data such as the heightmap
 407         // (no MapBlocks)
 408         // DEPRECATED? Sectors have no metadata anymore.
 409         void saveSectorMeta(ServerMapSector *sector);
 410         MapSector* loadSectorMeta(std::string dirname, bool save_after_load);
 411         bool loadSectorMeta(v2s16 p2d);
 412
 413         // Full load of a sector including all blocks.
 414         // returns true on success, false on failure.
 415         bool loadSectorFull(v2s16 p2d);
 416         // If sector is not found in memory, try to load it from disk.
 417         // Returns true if sector now resides in memory
 418         //bool deFlushSector(v2s16 p2d);
 419
 420         void saveBlock(MapBlock *block);
 421         // This will generate a sector with getSector if not found.
 422         void loadBlock(std::string sectordir, std::string blockfile, MapSector *sector, bool save_after_load=false);
 423         MapBlock* loadBlock(v3s16 p);
 424         // Database version
 425         void loadBlock(std::string *blob, v3s16 p3d, MapSector *sector, bool save_after_load=false);
 426
 427         // For debug printing
 428         virtual void PrintInfo(std::ostream &out);
 429
 430         bool isSavingEnabled(){ return m_map_saving_enabled; }
 431
 432         u64 getSeed(){ return m_seed; }
 433
 434 private:
 435         // Seed used for all kinds of randomness
 436         u64 m_seed;
 437
 438         std::string m_savedir;
 439         bool m_map_saving_enabled;
 440
 441 #if 0
 442         // Chunk size in MapSectors
 443         // If 0, chunks are disabled.
 444         s16 m_chunksize;
 445         // Chunks
 446         core::map<v2s16, MapChunk*> m_chunks;
 447 #endif
 448
 449         /*
 450                 Metadata is re-written on disk only if this is true.
 451                 This is reset to false when written on disk.
 452         */
 453         bool m_map_metadata_changed;
 454
 455         /*
 456                 SQLite database and statements
 457         */
 458         sqlite3 *m_database;
 459         sqlite3_stmt *m_database_read;
 460         sqlite3_stmt *m_database_write;
 461 };
 462
 463 /*
 464         ClientMap stuff
 465 */
 466
 467 #ifndef SERVER
 468
 469 struct MapDrawControl
 470 {
 471         MapDrawControl():
 472                 range_all(false),
 473                 wanted_range(50),
 474                 wanted_max_blocks(0),
 475                 wanted_min_range(0),
 476                 blocks_drawn(0),
 477                 blocks_would_have_drawn(0)
 478         {
 479         }
 480         // Overrides limits by drawing everything
 481         bool range_all;
 482         // Wanted drawing range
 483         float wanted_range;
 484         // Maximum number of blocks to draw
 485         u32 wanted_max_blocks;
 486         // Blocks in this range are drawn regardless of number of blocks drawn
 487         float wanted_min_range;
 488         // Number of blocks rendered is written here by the renderer
 489         u32 blocks_drawn;
 490         // Number of blocks that would have been drawn in wanted_range
 491         u32 blocks_would_have_drawn;
 492 };
 493
 494 class Client;
 495
 496 /*
 497         ClientMap
 498
 499         This is the only map class that is able to render itself on screen.
 500 */
 501
 502 class ClientMap : public Map, public scene::ISceneNode
 503 {
 504 public:
 505         ClientMap(
 506                         Client *client,
 507                         MapDrawControl &control,
 508                         scene::ISceneNode* parent,
 509                         scene::ISceneManager* mgr,
 510                         s32 id
 511         );
 512
 513         ~ClientMap();
 514
 515         s32 mapType() const
 516         {
 517                 return MAPTYPE_CLIENT;
 518         }
 519
 520         void drop()
 521         {
 522                 ISceneNode::drop();
 523         }
 524
 525         void updateCamera(v3f pos, v3f dir, f32 fov)
 526         {
 527                 JMutexAutoLock lock(m_camera_mutex);
 528                 m_camera_position = pos;
 529                 m_camera_direction = dir;
 530                 m_camera_fov = fov;
 531         }
 532
 533         /*
 534                 Forcefully get a sector from somewhere
 535         */
 536         MapSector * emergeSector(v2s16 p);
 537
 538         //void deSerializeSector(v2s16 p2d, std::istream &is);
 539
 540         /*
 541                 ISceneNode methods
 542         */
 543
 544         virtual void OnRegisterSceneNode();
 545
 546         virtual void render()
 547         {
 548                 video::IVideoDriver* driver = SceneManager->getVideoDriver();
 549                 driver->setTransform(video::ETS_WORLD, AbsoluteTransformation);
 550                 renderMap(driver, SceneManager->getSceneNodeRenderPass());
 551         }
 552
 553         virtual const core::aabbox3d<f32>& getBoundingBox() const
 554         {
 555                 return m_box;
 556         }
 557
 558         void renderMap(video::IVideoDriver* driver, s32 pass);
 559
 560         void renderPostFx();
 561
 562         /*
 563                 Methods for setting temporary modifications to nodes for
 564                 drawing.
 565
 566                 Returns true if something changed.
 567
 568                 All blocks whose mesh could have been changed are inserted
 569                 to affected_blocks.
 570         */
 571         bool setTempMod(v3s16 p, NodeMod mod,
 572                         core::map<v3s16, MapBlock*> *affected_blocks=NULL);
 573         bool clearTempMod(v3s16 p,
 574                         core::map<v3s16, MapBlock*> *affected_blocks=NULL);
 575         // Efficient implementation needs a cache of TempMods
 576         //void clearTempMods();
 577
 578         void expireMeshes(bool only_daynight_diffed);
 579
 580         /*
 581                 Update the faces of the given block and blocks on the
 582                 leading edge.
 583         */
 584         void updateMeshes(v3s16 blockpos, u32 daynight_ratio);
 585
 586         // Update meshes that touch the node
 587         //void updateNodeMeshes(v3s16 nodepos, u32 daynight_ratio);
 588
 589         // For debug printing
 590         virtual void PrintInfo(std::ostream &out);
 591
 592         // Check if sector was drawn on last render()
 593         bool sectorWasDrawn(v2s16 p)
 594         {
 595                 return (m_last_drawn_sectors.find(p) != NULL);
 596         }
 597
 598 private:
 599         Client *m_client;
 600
 601         core::aabbox3d<f32> m_box;
 602
 603         // This is the master heightmap mesh
 604         //scene::SMesh *mesh;
 605         //JMutex mesh_mutex;
 606
 607         MapDrawControl &m_control;
 608
 609         v3f m_camera_position;
 610         v3f m_camera_direction;
 611         f32 m_camera_fov;
 612         JMutex m_camera_mutex;
 613
 614         core::map<v2s16, bool> m_last_drawn_sectors;
 615 };
 616
 617 #endif
 618
 619 class MapVoxelManipulator : public VoxelManipulator
 620 {
 621 public:
 622         MapVoxelManipulator(Map *map);
 623         virtual ~MapVoxelManipulator();
 624
 625         virtual void clear()
 626         {
 627                 VoxelManipulator::clear();
 628                 m_loaded_blocks.clear();
 629         }
 630
 631         virtual void emerge(VoxelArea a, s32 caller_id=-1);
 632
 633         void blitBack(core::map<v3s16, MapBlock*> & modified_blocks);
 634
 635 protected:
 636         Map *m_map;
 637         /*
 638                 key = blockpos
 639                 value = block existed when loaded
 640         */
 641         core::map<v3s16, bool> m_loaded_blocks;
 642 };
 643
 644 class ManualMapVoxelManipulator : public MapVoxelManipulator
 645 {
 646 public:
 647         ManualMapVoxelManipulator(Map *map);
 648         virtual ~ManualMapVoxelManipulator();
 649
 650         void setMap(Map *map)
 651         {m_map = map;}
 652
 653         virtual void emerge(VoxelArea a, s32 caller_id=-1);
 654
 655         void initialEmerge(v3s16 blockpos_min, v3s16 blockpos_max);
 656
 657         // This is much faster with big chunks of generated data
 658         void blitBackAll(core::map<v3s16, MapBlock*> * modified_blocks);
 659
 660 protected:
 661         bool m_create_area;
 662 };
 663
 664 #endif
 665