/*
Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
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
#define MAP_HEADER
#include <jmutex.h>
+#include <jmutexautolock.h>
#include <jthread.h>
#include <iostream>
-
-#ifdef _WIN32
- #include <windows.h>
- #define sleep_s(x) Sleep((x*1000))
-#else
- #include <unistd.h>
- #define sleep_s(x) sleep(x)
-#endif
+#include <sstream>
#include "common_irrlicht.h"
#include "mapnode.h"
-#include "mapblock.h"
-#include "mapsector.h"
+#include "mapblock_nodemod.h"
#include "constants.h"
#include "voxel.h"
-#include "mapchunk.h"
-#include "nodemetadata.h"
+
+extern "C" {
+ #include "sqlite3.h"
+}
+
+class MapSector;
+class ServerMapSector;
+class ClientMapSector;
+class MapBlock;
+class NodeMetadata;
+
+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
};
virtual void onMapEditEvent(MapEditEvent *event) = 0;
};
-class Map : public NodeContainer
+class Map /*: public NodeContainer*/
{
public:
Map(std::ostream &dout);
virtual ~Map();
- virtual u16 nodeContainerId() const
+ /*virtual u16 nodeContainerId() const
{
return NODECONTAINER_ID_MAP;
- }
+ }*/
virtual s32 mapType() const
{
// On failure returns NULL
MapSector * getSectorNoGenerateNoExNoLock(v2s16 p2d);
- // On failure returns NULL
+ // Same as the above (there exists no lock anymore)
MapSector * getSectorNoGenerateNoEx(v2s16 p2d);
// On failure throws InvalidPositionException
MapSector * getSectorNoGenerate(v2s16 p2d);
MapBlock * getBlockNoCreate(v3s16 p);
// Returns NULL if not found
MapBlock * getBlockNoCreateNoEx(v3s16 p);
- // Gets an existing block or creates an empty one
- //MapBlock * getBlockCreate(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);
- // 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);
- }
+ void setNode(v3s16 p, MapNode & n);
// Returns a CONTENT_IGNORE node if not found
- MapNode getNodeNoEx(v3s16 p)
- {
- try{
- v3s16 blockpos = getNodeBlockPos(p);
- MapBlock * blockref = getBlockNoCreate(blockpos);
- v3s16 relpos = p - blockpos*MAP_BLOCKSIZE;
-
- return blockref->getNodeNoCheck(relpos);
- }
- catch(InvalidPositionException &e)
- {
- return MapNode(CONTENT_IGNORE);
- }
- }
+ MapNode getNodeNoEx(v3s16 p);
void unspreadLight(enum LightBank bank,
core::map<v3s16, u8> & from_nodes,
These handle lighting but not faces.
*/
void addNodeAndUpdate(v3s16 p, MapNode n,
- core::map<v3s16, MapBlock*> &modified_blocks);
+ core::map<v3s16, MapBlock*> &modified_blocks, std::string &player_name);
void removeNodeAndUpdate(v3s16 p,
core::map<v3s16, MapBlock*> &modified_blocks);
//core::aabbox3d<s16> 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);};
+
+ // 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<v3s16> *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<v2s16> &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<v2s16> &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<v3s16> *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<v3s16, MapBlock*> & modified_blocks);
core::map<MapEventReceiver*, bool> m_event_receivers;
core::map<v2s16, MapSector*> m_sectors;
- //JMutex m_sector_mutex;
// Be sure to set this to NULL when the cached sector is deleted
MapSector *m_sector_cache;
This is the only map class that is able to generate map.
*/
-struct ChunkMakeData;
-
class ServerMap : public Map
{
public:
return MAPTYPE_SERVER;
}
- /*
- Map generation
- */
-
- // Returns the position of the chunk where the sector is in
- v2s16 sector_to_chunk(v2s16 sectorpos)
- {
- if(m_chunksize == 0)
- return v2s16(0,0);
- sectorpos.X += m_chunksize / 2;
- sectorpos.Y += m_chunksize / 2;
- v2s16 chunkpos = getContainerPos(sectorpos, m_chunksize);
- return chunkpos;
- }
-
- // Returns the position of the (0,0) sector of the chunk
- v2s16 chunk_to_sector(v2s16 chunkpos)
- {
- if(m_chunksize == 0)
- return v2s16(0,0);
- v2s16 sectorpos(
- chunkpos.X * m_chunksize,
- chunkpos.Y * m_chunksize
- );
- sectorpos.X -= m_chunksize / 2;
- sectorpos.Y -= m_chunksize / 2;
- return sectorpos;
- }
-
- /*
- Get a chunk.
- */
- MapChunk *getChunk(v2s16 chunkpos)
- {
- core::map<v2s16, MapChunk*>::Node *n;
- n = m_chunks.find(chunkpos);
- if(n == NULL)
- return NULL;
- return n->getValue();
- }
-
- /*
- True if the chunk and its neighbors are fully generated.
- It means the chunk will not be touched in the future by the
- generator. If false, generateChunk will make it true.
- */
- bool chunkNonVolatile(v2s16 chunkpos)
- {
- if(m_chunksize == 0)
- return true;
-
- /*for(s16 x=-1; x<=1; x++)
- for(s16 y=-1; y<=1; y++)*/
- s16 x=0;
- s16 y=0;
- {
- v2s16 chunkpos0 = chunkpos + v2s16(x,y);
- MapChunk *chunk = getChunk(chunkpos);
- if(chunk == NULL)
- return false;
- if(chunk->getGenLevel() != GENERATED_FULLY)
- return false;
- }
- return true;
- }
-
- /*
- Returns true if any chunk is marked as modified
- */
- bool anyChunkModified()
- {
- for(core::map<v2s16, MapChunk*>::Iterator
- i = m_chunks.getIterator();
- i.atEnd()==false; i++)
- {
- v2s16 p = i.getNode()->getKey();
- MapChunk *chunk = i.getNode()->getValue();
- if(chunk->isModified())
- return true;
- }
- return false;
- }
-
- void setChunksNonModified()
- {
- for(core::map<v2s16, MapChunk*>::Iterator
- i = m_chunks.getIterator();
- i.atEnd()==false; i++)
- {
- v2s16 p = i.getNode()->getKey();
- MapChunk *chunk = i.getNode()->getValue();
- chunk->setModified(false);
- }
- }
-
- /*
- Chunks are generated by using these and makeChunk().
- */
- void initChunkMake(ChunkMakeData &data, v2s16 chunkpos);
- MapChunk* finishChunkMake(ChunkMakeData &data,
- core::map<v3s16, MapBlock*> &changed_blocks);
-
- /*
- Generate a chunk.
-
- All chunks touching this one can be altered also.
- */
- /*MapChunk* generateChunkRaw(v2s16 chunkpos,
- core::map<v3s16, MapBlock*> &changed_blocks,
- bool force=false);*/
-
- /*
- Generate a chunk and its neighbors so that it won't be touched
- anymore.
- */
- /*MapChunk* generateChunk(v2s16 chunkpos,
- core::map<v3s16, MapBlock*> &changed_blocks);*/
-
- /*
- Generate a sector.
-
- This is mainly called by generateChunkRaw.
- */
- //ServerMapSector * generateSector(v2s16 p);
-
/*
Get a sector from somewhere.
- Check memory
- - Check disk (loads blocks also)
+ - Check disk (doesn't load blocks)
- Create blank one
*/
ServerMapSector * createSector(v2s16 p);
/*
- Get a sector from somewhere.
- - Check memory
- - Check disk (loads blocks also)
- - Generate chunk
+ Blocks are generated by using these and makeBlock().
*/
- /*MapSector * emergeSector(v2s16 p,
- core::map<v3s16, MapBlock*> &changed_blocks);*/
+ void initBlockMake(mapgen::BlockMakeData *data, v3s16 blockpos);
+ MapBlock* finishBlockMake(mapgen::BlockMakeData *data,
+ core::map<v3s16, MapBlock*> &changed_blocks);
- /*MapSector * emergeSector(v2s16 p)
- {
- core::map<v3s16, MapBlock*> changed_blocks;
- return emergeSector(p, changed_blocks);
- }*/
-
+ // A non-threaded wrapper to the above
MapBlock * generateBlock(
v3s16 p,
- MapBlock *original_dummy,
- ServerMapSector *sector,
- core::map<v3s16, MapBlock*> &changed_blocks,
- core::map<v3s16, MapBlock*> &lighting_invalidated_blocks
+ core::map<v3s16, MapBlock*> &modified_blocks
);
/*
- Create blank
*/
MapBlock * createBlock(v3s16 p);
-
- /*
- only_from_disk, changed_blocks and lighting_invalidated_blocks
- are not properly used by the new map generator.
- */
- MapBlock * emergeBlock(
- v3s16 p,
- bool only_from_disk,
- core::map<v3s16, MapBlock*> &changed_blocks,
- core::map<v3s16, MapBlock*> &lighting_invalidated_blocks
- );
-#if 0
/*
Forcefully get a block from somewhere.
-
- 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.
-
- - A block that is in changed_blocks may not be in
- lighting_invalidated_blocks.
+ - Memory
+ - Load from disk
+ - Generate
*/
- MapBlock * emergeBlock(
- v3s16 p,
- bool only_from_disk,
- core::map<v3s16, MapBlock*> &changed_blocks,
- core::map<v3s16, MapBlock*> &lighting_invalidated_blocks
- );
-#endif
+ MapBlock * emergeBlock(v3s16 p, bool allow_generate=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 createDir(std::string path);
- void createSaveDir();
- // returns something like "xxxxxxxx"
- std::string getSectorSubDir(v2s16 pos);
+ 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);
+
+ /*
+ 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(bool only_changed);
//void loadAll();
+ void listAllLoadableBlocks(core::list<v3s16> &dst);
+
// Saves map seed and possibly other stuff
void saveMapMeta();
void loadMapMeta();
- void saveChunkMeta();
- void loadChunkMeta();
+ /*void saveChunkMeta();
+ void loadChunkMeta();*/
// The sector mutex should be locked when calling most of these
// (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.
void saveBlock(MapBlock *block);
// This will generate a sector with getSector if not found.
- void loadBlock(std::string sectordir, std::string blockfile, MapSector *sector);
+ 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
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<v2s16, MapChunk*> 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;
};
/*
ISceneNode::drop();
}
- void updateCamera(v3f pos, v3f dir)
+ 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;
}
/*
*/
MapSector * emergeSector(v2s16 p);
- void deSerializeSector(v2s16 p2d, std::istream &is);
+ //void deSerializeSector(v2s16 p2d, std::istream &is);
/*
ISceneNode methods
void renderMap(video::IVideoDriver* driver, s32 pass);
+ void renderPostFx();
+
/*
Methods for setting temporary modifications to nodes for
drawing.
// 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;
v3f m_camera_position;
v3f m_camera_direction;
+ f32 m_camera_fov;
JMutex m_camera_mutex;
-
+
+ core::map<v2s16, bool> m_last_drawn_sectors;
};
#endif
bool m_create_area;
};
-struct ChunkMakeData
-{
- bool no_op;
- ManualMapVoxelManipulator vmanip;
- u64 seed;
- v2s16 chunkpos;
- s16 y_blocks_min;
- s16 y_blocks_max;
- v2s16 sectorpos_base;
- s16 sectorpos_base_size;
- v2s16 sectorpos_bigbase;
- s16 sectorpos_bigbase_size;
- s16 max_spread_amount;
- UniqueQueue<v3s16> transforming_liquid;
-
- ChunkMakeData():
- no_op(false),
- vmanip(NULL),
- seed(0)
- {}
-};
-
-void makeChunk(ChunkMakeData *data);
-
#endif
projects / oweals / minetest.git / blobdiff