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         Mapgen *mapgen;
  50         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, EmergeManager *emerge);
  72         MapgenParams *createMapgenParams(std::string mgname);
  73         Mapgen *getMapgen();
  74         bool enqueueBlockEmerge(u16 peer_id, v3s16 p, bool allow_generate);
  75         bool popBlockEmerge(v3s16 *pos, u8 *flags);
  76
  77         bool registerMapgen(std::string name, MapgenFactory *mgfactory);
  78         MapgenParams *getParamsFromSettings(Settings *settings);
  79         void setParamsToSettings(Settings *settings);
  80
  81         //mapgen helper methods
  82         Biome *getBiomeAtPoint(v3s16 p);
  83         int getGroundLevelAtPoint(v2s16 p);
  84         bool isBlockUnderground(v3s16 blockpos);
  85         u32 getBlockSeed(v3s16 p);
  86 };
  87
  88 class EmergeThread : public SimpleThread
  89 {
  90         Server *m_server;
  91         ServerMap *map;
  92         EmergeManager *emerge;
  93         Mapgen *mapgen;
  94         bool enable_mapgen_debug_info;
  95
  96 public:
  97         Event qevent;
  98         std::queue<v3s16> blockqueue;
  99
 100         EmergeThread(Server *server):
 101                 SimpleThread(),
 102                 m_server(server),
 103                 map(NULL),
 104                 emerge(NULL),
 105                 mapgen(NULL)
 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 getBlockOrStartGen(v3s16 p, MapBlock **b,
 122                                                         BlockMakeData *data, bool allow_generate);
 123 };
 124
 125 #endif