]> git.lizzy.rs Git - dragonfireclient.git/blobdiff - src/map.h
projects / dragonfireclient.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Omnicleanup: header cleanup, add ModApiUtil shared between game and mainmenu
[dragonfireclient.git] / src / map.h
diff --git a/src/map.h b/src/map.h
index d356da2d1c65f00ce6fb39019a21af2d39896465..2f8bfaebabc4cb19bba80af6964982de61b47ef5 100644 (file)
--- a/src/map.h
+++ b/src/map.h
@@ -20,17 +20,16 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #ifndef MAP_HEADER
 #define MAP_HEADER
 
-#include <jmutex.h>
-#include <jmutexautolock.h>
-#include <jthread.h>
 #include <iostream>
 #include <sstream>
+#include <set>
+#include <map>
+#include <list>
 
 #include "irrlichttypes_bloated.h"
 #include "mapnode.h"
 #include "constants.h"
 #include "voxel.h"
-#include "mapgen.h" //for BlockMakeData and EmergeManager
 #include "modifiedstate.h"
 #include "util/container.h"
 #include "nodetimer.h"
@@ -47,7 +46,9 @@ class NodeMetadata;
 class IGameDef;
 class IRollbackReportSink;
 class EmergeManager;
-class BlockMakeData;
+class ServerEnvironment;
+struct BlockMakeData;
+struct MapgenParams;
 
 
 /*
@@ -75,7 +76,7 @@ struct MapEditEvent
        MapEditEventType type;
        v3s16 p;
        MapNode n;
-       core::map<v3s16, bool> modified_blocks;
+       std::set<v3s16> modified_blocks;
        u16 already_known_by_peer;
 
        MapEditEvent():
@@ -90,14 +91,7 @@ struct MapEditEvent
                event->type = type;
                event->p = p;
                event->n = n;
-               for(core::map<v3s16, bool>::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;
                return event;
        }
 
@@ -117,11 +111,11 @@ struct MapEditEvent
                case MEET_OTHER:
                {
                        VoxelArea a;
-                       for(core::map<v3s16, bool>::Iterator
-                                       i = modified_blocks.getIterator();
-                                       i.atEnd()==false; i++)
+                       for(std::set<v3s16>::iterator
+                                       i = modified_blocks.begin();
+                                       i != modified_blocks.end(); ++i)
                        {
-                               v3s16 p = i.getNode()->getKey();
+                               v3s16 p = *i;
                                v3s16 np1 = p*MAP_BLOCKSIZE;
                                v3s16 np2 = np1 + v3s16(1,1,1)*MAP_BLOCKSIZE - v3s16(1,1,1);
                                a.addPoint(np1);
@@ -186,7 +180,7 @@ class Map /*: public NodeContainer*/
        */
        virtual MapSector * emergeSector(v2s16 p){ return NULL; }
        virtual MapSector * emergeSector(v2s16 p,
-                       core::map<v3s16, MapBlock*> &changed_blocks){ return NULL; }
+                       std::map<v3s16, MapBlock*> &changed_blocks){ return NULL; }
 
        // Returns InvalidPositionException if not found
        MapBlock * getBlockNoCreate(v3s16 p);
@@ -212,42 +206,42 @@ class Map /*: public NodeContainer*/
        MapNode getNodeNoEx(v3s16 p);
 
        void unspreadLight(enum LightBank bank,
-                       core::map<v3s16, u8> & from_nodes,
-                       core::map<v3s16, bool> & light_sources,
-                       core::map<v3s16, MapBlock*> & modified_blocks);
+                       std::map<v3s16, u8> & from_nodes,
+                       std::set<v3s16> & light_sources,
+                       std::map<v3s16, MapBlock*> & modified_blocks);
 
        void unLightNeighbors(enum LightBank bank,
                        v3s16 pos, u8 lightwas,
-                       core::map<v3s16, bool> & light_sources,
-                       core::map<v3s16, MapBlock*> & modified_blocks);
+                       std::set<v3s16> & light_sources,
+                       std::map<v3s16, MapBlock*> & modified_blocks);
 
        void spreadLight(enum LightBank bank,
-                       core::map<v3s16, bool> & from_nodes,
-                       core::map<v3s16, MapBlock*> & modified_blocks);
+                       std::set<v3s16> & from_nodes,
+                       std::map<v3s16, MapBlock*> & modified_blocks);
 
        void lightNeighbors(enum LightBank bank,
                        v3s16 pos,
-                       core::map<v3s16, MapBlock*> & modified_blocks);
+                       std::map<v3s16, MapBlock*> & modified_blocks);
 
        v3s16 getBrightestNeighbour(enum LightBank bank, v3s16 p);
 
        s16 propagateSunlight(v3s16 start,
-                       core::map<v3s16, MapBlock*> & modified_blocks);
+                       std::map<v3s16, MapBlock*> & modified_blocks);
 
        void updateLighting(enum LightBank bank,
-                       core::map<v3s16, MapBlock*>  & a_blocks,
-                       core::map<v3s16, MapBlock*> & modified_blocks);
+                       std::map<v3s16, MapBlock*>  & a_blocks,
+                       std::map<v3s16, MapBlock*> & modified_blocks);
 
-       void updateLighting(core::map<v3s16, MapBlock*>  & a_blocks,
-                       core::map<v3s16, MapBlock*> & modified_blocks);
+       void updateLighting(std::map<v3s16, MapBlock*>  & a_blocks,
+                       std::map<v3s16, MapBlock*> & modified_blocks);
 
        /*
                These handle lighting but not faces.
        */
        void addNodeAndUpdate(v3s16 p, MapNode n,
-                       core::map<v3s16, MapBlock*> &modified_blocks);
+                       std::map<v3s16, MapBlock*> &modified_blocks);
        void removeNodeAndUpdate(v3s16 p,
-                       core::map<v3s16, MapBlock*> &modified_blocks);
+                       std::map<v3s16, MapBlock*> &modified_blocks);
 
        /*
                Wrappers for the latter ones.
@@ -281,12 +275,18 @@ class Map /*: public NodeContainer*/
                Saves modified blocks before unloading on MAPTYPE_SERVER.
        */
        void timerUpdate(float dtime, float unload_timeout,
-                       core::list<v3s16> *unloaded_blocks=NULL);
+                       std::list<v3s16> *unloaded_blocks=NULL);
+
+       /*
+               Unloads all blocks with a zero refCount().
+               Saves modified blocks before unloading on MAPTYPE_SERVER.
+       */
+       void unloadUnreferencedBlocks(std::list<v3s16> *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<v2s16> &list);
+       void deleteSectors(std::list<v2s16> &list);
 
 #if 0
        /*
@@ -301,8 +301,8 @@ class Map /*: public NodeContainer*/
        // For debug printing. Prints "Map: ", "ServerMap: " or "ClientMap: "
        virtual void PrintInfo(std::ostream &out);
 
-       void transformLiquids(core::map<v3s16, MapBlock*> & modified_blocks);
-       void transformLiquidsFinite(core::map<v3s16, MapBlock*> & modified_blocks);
+       void transformLiquids(std::map<v3s16, MapBlock*> & modified_blocks);
+       void transformLiquidsFinite(std::map<v3s16, MapBlock*> & modified_blocks);
 
        /*
                Node metadata
@@ -325,7 +325,7 @@ class Map /*: public NodeContainer*/
        /*
                Misc.
        */
-       core::map<v2s16, MapSector*> *getSectorsPtr(){return &m_sectors;}
+       std::map<v2s16, MapSector*> *getSectorsPtr(){return &m_sectors;}
 
        /*
                Variables
@@ -334,15 +334,19 @@ class Map /*: public NodeContainer*/
        void transforming_liquid_add(v3s16 p);
        s32 transforming_liquid_size();
 
+       virtual s16 getHeat(v3s16 p);
+       virtual s16 getHumidity(v3s16 p);
+
 protected:
+       friend class LuaVoxelManip;
 
        std::ostream &m_dout; // A bit deprecated, could be removed
 
        IGameDef *m_gamedef;
 
-       core::map<MapEventReceiver*, bool> m_event_receivers;
+       std::set<MapEventReceiver*> m_event_receivers;
 
-       core::map<v2s16, MapSector*> m_sectors;
+       std::map<v2s16, MapSector*> m_sectors;
 
        // Be sure to set this to NULL when the cached sector is deleted
        MapSector *m_sector_cache;
@@ -385,13 +389,7 @@ class ServerMap : public Map
        */
        bool initBlockMake(BlockMakeData *data, v3s16 blockpos);
        MapBlock *finishBlockMake(BlockMakeData *data,
-                       core::map<v3s16, MapBlock*> &changed_blocks);
-
-       // A non-threaded wrapper to the above  - DEFUNCT
-/*     MapBlock * generateBlock(
-                       v3s16 p,
-                       core::map<v3s16, MapBlock*> &modified_blocks
-       );*/
+                       std::map<v3s16, MapBlock*> &changed_blocks);
 
        /*
                Get a block from somewhere.
@@ -443,10 +441,8 @@ class ServerMap : public Map
        void endSave();
 
        void save(ModifiedState save_level);
-       //void loadAll();
-
-       void listAllLoadableBlocks(core::list<v3s16> &dst);
-
+       void listAllLoadableBlocks(std::list<v3s16> &dst);
+       void listAllLoadedBlocks(std::list<v3s16> &dst);
        // Saves map seed and possibly other stuff
        void saveMapMeta();
        void loadMapMeta();
@@ -488,6 +484,10 @@ class ServerMap : public Map
 
        // Parameters fed to the Mapgen
        MapgenParams *m_mgparams;
+
+       virtual s16 getHeat(ServerEnvironment *env, v3s16 p, MapBlock *block = NULL);
+       virtual s16 getHumidity(ServerEnvironment *env, v3s16 p, MapBlock *block = NULL);
+
 private:
        // Seed used for all kinds of randomness in generation
        u64 m_seed;
@@ -538,15 +538,15 @@ class MapVoxelManipulator : public VoxelManipulator
 
        virtual void emerge(VoxelArea a, s32 caller_id=-1);
 
-       void blitBack(core::map<v3s16, MapBlock*> & modified_blocks);
-       
+       void blitBack(std::map<v3s16, MapBlock*> & modified_blocks);
+
+protected:
+       Map *m_map;
        /*
                key = blockpos
                value = flags describing the block
        */
-       core::map<v3s16, u8> m_loaded_blocks;
-protected:
-       Map *m_map;
+       std::map<v3s16, u8> m_loaded_blocks;
 };
 
 class ManualMapVoxelManipulator : public MapVoxelManipulator
@@ -560,10 +560,11 @@ class ManualMapVoxelManipulator : public MapVoxelManipulator
 
        virtual void emerge(VoxelArea a, s32 caller_id=-1);
 
-       void initialEmerge(v3s16 blockpos_min, v3s16 blockpos_max);
+       void initialEmerge(v3s16 blockpos_min, v3s16 blockpos_max,
+                                               bool load_if_inexistent = true);
 
        // This is much faster with big chunks of generated data
-       void blitBackAll(core::map<v3s16, MapBlock*> * modified_blocks);
+       void blitBackAll(std::map<v3s16, MapBlock*> * modified_blocks);
 
 protected:
        bool m_create_area;
Dragonfireclient is an utility client for the Voxelengine minetest (http://minetest.net/). The client was created by Elias Fleckenstein and is inspired by the Minecraft clients Liquid Bounce and Impact. Discord: https://discord.gg/kab99uu for more information.