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