src/emerge.h

   1 /*
   2 Minetest
   3 Copyright (C) 2010-2013 kwolekr, Ryan Kwolek <kwolekr@minetest.net>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License along
  16 with this program; if not, write to the Free Software Foundation, Inc.,
  17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #ifndef EMERGE_HEADER
  21 #define EMERGE_HEADER
  22
  23 #include <map>
  24 #include <queue>
  25 #include "util/thread.h"
  26
  27 #define MGPARAMS_SET_MGNAME      1
  28 #define MGPARAMS_SET_SEED        2
  29 #define MGPARAMS_SET_WATER_LEVEL 4
  30 #define MGPARAMS_SET_FLAGS       8
  31
  32 #define BLOCK_EMERGE_ALLOWGEN (1<<0)
  33
  34 #define EMERGE_DBG_OUT(x) \
  35         { if (enable_mapgen_debug_info) \
  36         infostream << "EmergeThread: " x << std::endl; }
  37
  38 class Mapgen;
  39 struct MapgenParams;
  40 struct MapgenFactory;
  41 class Biome;
  42 class BiomeDefManager;
  43 class EmergeThread;
  44 class ManualMapVoxelManipulator;
  45
  46 #include "server.h"
  47
  48 struct BlockMakeData {
  49         ManualMapVoxelManipulator *vmanip;
  50         u64 seed;
  51         v3s16 blockpos_min;
  52         v3s16 blockpos_max;
  53         v3s16 blockpos_requested;
  54         UniqueQueue<v3s16> transforming_liquid;
  55         INodeDefManager *nodedef;
  56
  57         BlockMakeData():
  58                 vmanip(NULL),
  59                 seed(0),
  60                 nodedef(NULL)
  61         {}
  62
  63         ~BlockMakeData() { delete vmanip; }
  64 };
  65
  66 struct BlockEmergeData {
  67         u16 peer_requested;
  68         u8 flags;
  69 };
  70
  71 class EmergeManager {
  72 public:
  73         INodeDefManager *ndef;
  74
  75         std::map<std::string, MapgenFactory *> mglist;
  76
  77         std::vector<Mapgen *> mapgen;
  78         std::vector<EmergeThread *> emergethread;
  79
  80         //settings
  81         MapgenParams *params;
  82         bool mapgen_debug_info;
  83         u16 qlimit_total;
  84         u16 qlimit_diskonly;
  85         u16 qlimit_generate;
  86
  87         MapgenParams *luaoverride_params;
  88         u32 luaoverride_params_modified;
  89         u32 luaoverride_flagmask;
  90
  91         //block emerge queue data structures
  92         JMutex queuemutex;
  93         std::map<v3s16, BlockEmergeData *> blocks_enqueued;
  94         std::map<u16, u16> peer_queue_count;
  95
  96         //Mapgen-related structures
  97         BiomeDefManager *biomedef;
  98         std::vector<Ore *> ores;
  99         std::vector<Decoration *> decorations;
 100
 101         EmergeManager(IGameDef *gamedef);
 102         ~EmergeManager();
 103
 104         void initMapgens(MapgenParams *mgparams);
 105         Mapgen *getCurrentMapgen();
 106         Mapgen *createMapgen(std::string mgname, int mgid,
 107                                                 MapgenParams *mgparams);
 108         MapgenParams *createMapgenParams(std::string mgname);
 109         bool enqueueBlockEmerge(u16 peer_id, v3s16 p, bool allow_generate);
 110
 111         void registerMapgen(std::string name, MapgenFactory *mgfactory);
 112         MapgenParams *getParamsFromSettings(Settings *settings);
 113         void setParamsToSettings(Settings *settings);
 114
 115         //mapgen helper methods
 116         Biome *getBiomeAtPoint(v3s16 p);
 117         int getGroundLevelAtPoint(v2s16 p);
 118         bool isBlockUnderground(v3s16 blockpos);
 119         u32 getBlockSeed(v3s16 p);
 120 };
 121
 122 class EmergeThread : public SimpleThread
 123 {
 124 public:
 125         Server *m_server;
 126         ServerMap *map;
 127         EmergeManager *emerge;
 128         Mapgen *mapgen;
 129         bool enable_mapgen_debug_info;
 130         int id;
 131
 132         Event qevent;
 133         std::queue<v3s16> blockqueue;
 134
 135         EmergeThread(Server *server, int ethreadid):
 136                 SimpleThread(),
 137                 m_server(server),
 138                 map(NULL),
 139                 emerge(NULL),
 140                 mapgen(NULL),
 141                 id(ethreadid)
 142         {
 143         }
 144
 145         void *Thread();
 146
 147         void trigger()
 148         {
 149                 setRun(true);
 150                 if(IsRunning() == false)
 151                 {
 152                         Start();
 153                 }
 154         }
 155
 156         bool popBlockEmerge(v3s16 *pos, u8 *flags);
 157         bool getBlockOrStartGen(v3s16 p, MapBlock **b,
 158                                                         BlockMakeData *data, bool allow_generate);
 159 };
 160
 161 #endif