src/emerge.h

   1 #ifndef EMERGE_HEADER
   2 #define EMERGE_HEADER
   3
   4 #include <map>
   5 #include <queue>
   6 #include "util/thread.h"
   7
   8 #define BLOCK_EMERGE_ALLOWGEN (1<<0)
   9
  10 #define EMERGE_DBG_OUT(x) \
  11         { if (enable_mapgen_debug_info) \
  12         infostream << "EmergeThread: " x << std::endl; }
  13
  14 class Mapgen;
  15 class MapgenParams;
  16 class MapgenFactory;
  17 class Biome;
  18 class BiomeDefManager;
  19 class EmergeThread;
  20 class ManualMapVoxelManipulator;
  21
  22 #include "server.h"
  23
  24 struct BlockMakeData {
  25         ManualMapVoxelManipulator *vmanip;
  26         u64 seed;
  27         v3s16 blockpos_min;
  28         v3s16 blockpos_max;
  29         v3s16 blockpos_requested;
  30         UniqueQueue<v3s16> transforming_liquid;
  31         INodeDefManager *nodedef;
  32
  33         BlockMakeData():
  34                 vmanip(NULL),
  35                 seed(0),
  36                 nodedef(NULL)
  37         {}
  38
  39         ~BlockMakeData() { delete vmanip; }
  40 };
  41
  42 struct BlockEmergeData {
  43         u16 peer_requested;
  44         u8 flags;
  45 };
  46
  47 class EmergeManager {
  48 public:
  49         std::map<std::string, MapgenFactory *> mglist;
  50
  51         std::vector<Mapgen *> mapgen;
  52         std::vector<EmergeThread *> emergethread;
  53
  54         //settings
  55         MapgenParams *params;
  56         bool mapgen_debug_info;
  57         u16 qlimit_total;
  58         u16 qlimit_diskonly;
  59         u16 qlimit_generate;
  60
  61         //block emerge queue data structures
  62         JMutex queuemutex;
  63         std::map<v3s16, BlockEmergeData *> blocks_enqueued;
  64         std::map<u16, u16> peer_queue_count;
  65
  66         //Mapgen-related structures
  67         BiomeDefManager *biomedef;
  68         std::vector<Ore *> ores;
  69
  70         EmergeManager(IGameDef *gamedef, BiomeDefManager *bdef);
  71         ~EmergeManager();
  72
  73         void initMapgens(MapgenParams *mgparams);
  74         Mapgen *createMapgen(std::string mgname, int mgid,
  75                                                 MapgenParams *mgparams);
  76         MapgenParams *createMapgenParams(std::string mgname);
  77         bool enqueueBlockEmerge(u16 peer_id, v3s16 p, bool allow_generate);
  78
  79         void registerMapgen(std::string name, MapgenFactory *mgfactory);
  80         MapgenParams *getParamsFromSettings(Settings *settings);
  81         void setParamsToSettings(Settings *settings);
  82
  83         //mapgen helper methods
  84         Biome *getBiomeAtPoint(v3s16 p);
  85         int getGroundLevelAtPoint(v2s16 p);
  86         bool isBlockUnderground(v3s16 blockpos);
  87         u32 getBlockSeed(v3s16 p);
  88 };
  89
  90 class EmergeThread : public SimpleThread
  91 {
  92         Server *m_server;
  93         ServerMap *map;
  94         EmergeManager *emerge;
  95         Mapgen *mapgen;
  96         bool enable_mapgen_debug_info;
  97         int id;
  98
  99 public:
 100         Event qevent;
 101         std::queue<v3s16> blockqueue;
 102
 103         EmergeThread(Server *server, int ethreadid):
 104                 SimpleThread(),
 105                 m_server(server),
 106                 map(NULL),
 107                 emerge(NULL),
 108                 mapgen(NULL),
 109                 id(ethreadid)
 110         {
 111         }
 112
 113         void *Thread();
 114
 115         void trigger()
 116         {
 117                 setRun(true);
 118                 if(IsRunning() == false)
 119                 {
 120                         Start();
 121                 }
 122         }
 123
 124         bool popBlockEmerge(v3s16 *pos, u8 *flags);
 125         bool getBlockOrStartGen(v3s16 p, MapBlock **b,
 126                                                         BlockMakeData *data, bool allow_generate);
 127 };
 128
 129 #endif