#include "log.h"
#include "map.h"
#include "mapblock.h"
-#include "mapgen_flat.h"
-#include "mapgen_fractal.h"
-#include "mapgen_v5.h"
-#include "mapgen_v6.h"
-#include "mapgen_v7.h"
-#include "mapgen_singlenode.h"
#include "mg_biome.h"
#include "mg_ore.h"
#include "mg_decoration.h"
#include "settings.h"
#include "voxel.h"
-
-struct MapgenDesc {
- const char *name;
- MapgenFactory *factory;
- bool is_user_visible;
-};
-
class EmergeThread : public Thread {
public:
bool enable_mapgen_debug_info;
friend class EmergeManager;
};
-////
-//// Built-in mapgens
-////
-
-MapgenDesc g_reg_mapgens[] = {
- {"v5", new MapgenFactoryV5, true},
- {"v6", new MapgenFactoryV6, true},
- {"v7", new MapgenFactoryV7, true},
- {"flat", new MapgenFactoryFlat, true},
- {"fractal", new MapgenFactoryFractal, true},
- {"singlenode", new MapgenFactorySinglenode, false},
-};
-
////
//// EmergeManager
////
-EmergeManager::EmergeManager(IGameDef *gamedef)
+EmergeManager::EmergeManager(Server *server)
{
- this->ndef = gamedef->getNodeDefManager();
- this->biomemgr = new BiomeManager(gamedef);
- this->oremgr = new OreManager(gamedef);
- this->decomgr = new DecorationManager(gamedef);
- this->schemmgr = new SchematicManager(gamedef);
+ this->ndef = server->getNodeDefManager();
+ this->biomemgr = new BiomeManager(server);
+ this->oremgr = new OreManager(server);
+ this->decomgr = new DecorationManager(server);
+ this->schemmgr = new SchematicManager(server);
this->gen_notify_on = 0;
// Note that accesses to this variable are not synchronized.
m_qlimit_generate = 1;
for (s16 i = 0; i < nthreads; i++)
- m_threads.push_back(new EmergeThread((Server *)gamedef, i));
+ m_threads.push_back(new EmergeThread(server, i));
infostream << "EmergeManager: using " << nthreads << " threads" << std::endl;
}
delete oremgr;
delete decomgr;
delete schemmgr;
-
- delete params.sparams;
}
-void EmergeManager::loadMapgenParams()
-{
- params.load(*g_settings);
-}
-
-
-void EmergeManager::initMapgens()
+bool EmergeManager::initMapgens(MapgenParams *params)
{
if (m_mapgens.size())
- return;
-
- MapgenFactory *mgfactory = getMapgenFactory(params.mg_name);
- if (!mgfactory) {
- errorstream << "EmergeManager: mapgen " << params.mg_name <<
- " not registered; falling back to " << DEFAULT_MAPGEN << std::endl;
-
- params.mg_name = DEFAULT_MAPGEN;
-
- mgfactory = getMapgenFactory(params.mg_name);
- FATAL_ERROR_IF(mgfactory == NULL, "Couldn't use any mapgen!");
- }
+ return false;
- if (!params.sparams) {
- params.sparams = mgfactory->createMapgenParams();
- params.sparams->readParams(g_settings);
- }
+ this->mgparams = params;
for (u32 i = 0; i != m_threads.size(); i++) {
- Mapgen *mg = mgfactory->createMapgen(i, ¶ms, this);
+ Mapgen *mg = Mapgen::createMapgen(params->mgtype, i, params, this);
m_mapgens.push_back(mg);
}
+
+ return true;
}
void *callback_param)
{
EmergeThread *thread = NULL;
+ bool entry_already_exists = false;
{
MutexAutoLock queuelock(m_queue_mutex);
if (!pushBlockEmergeData(blockpos, peer_id, flags,
- callback, callback_param))
+ callback, callback_param, &entry_already_exists))
return false;
+ if (entry_already_exists)
+ return true;
+
thread = getOptimalThread();
thread->pushBlock(blockpos);
}
// Mapgen-related helper functions
//
+
+// TODO(hmmmm): Move this to ServerMap
v3s16 EmergeManager::getContainingChunk(v3s16 blockpos)
{
- return getContainingChunk(blockpos, params.chunksize);
+ return getContainingChunk(blockpos, mgparams->chunksize);
}
-
+// TODO(hmmmm): Move this to ServerMap
v3s16 EmergeManager::getContainingChunk(v3s16 blockpos, s16 chunksize)
{
s16 coff = -chunksize / 2;
}
+int EmergeManager::getSpawnLevelAtPoint(v2s16 p)
+{
+ if (m_mapgens.size() == 0 || !m_mapgens[0]) {
+ errorstream << "EmergeManager: getSpawnLevelAtPoint() called"
+ " before mapgen init" << std::endl;
+ return 0;
+ }
+
+ return m_mapgens[0]->getSpawnLevelAtPoint(p);
+}
+
+
int EmergeManager::getGroundLevelAtPoint(v2s16 p)
{
if (m_mapgens.size() == 0 || !m_mapgens[0]) {
return m_mapgens[0]->getGroundLevelAtPoint(p);
}
-
+// TODO(hmmmm): Move this to ServerMap
bool EmergeManager::isBlockUnderground(v3s16 blockpos)
{
#if 0
#endif
// Use a simple heuristic; the above method is wildly inaccurate anyway.
- return blockpos.Y * (MAP_BLOCKSIZE + 1) <= params.water_level;
-}
-
-
-void EmergeManager::getMapgenNames(
- std::vector<const char *> *mgnames, bool include_hidden)
-{
- for (u32 i = 0; i != ARRLEN(g_reg_mapgens); i++) {
- if (include_hidden || g_reg_mapgens[i].is_user_visible)
- mgnames->push_back(g_reg_mapgens[i].name);
- }
+ return blockpos.Y * (MAP_BLOCKSIZE + 1) <= mgparams->water_level;
}
-
-MapgenFactory *EmergeManager::getMapgenFactory(const std::string &mgname)
-{
- for (u32 i = 0; i != ARRLEN(g_reg_mapgens); i++) {
- if (mgname == g_reg_mapgens[i].name)
- return g_reg_mapgens[i].factory;
- }
-
- return NULL;
-}
-
-
bool EmergeManager::pushBlockEmergeData(
v3s16 pos,
u16 peer_requested,
u16 flags,
EmergeCompletionCallback callback,
- void *callback_param)
+ void *callback_param,
+ bool *entry_already_exists)
{
u16 &count_peer = m_peer_queue_count[peer_requested];
findres = m_blocks_enqueued.insert(std::make_pair(pos, BlockEmergeData()));
BlockEmergeData &bedata = findres.first->second;
- bool update_existing = !findres.second;
+ *entry_already_exists = !findres.second;
if (callback)
bedata.callbacks.push_back(std::make_pair(callback, callback_param));
- if (update_existing) {
+ if (*entry_already_exists) {
bedata.flags |= flags;
} else {
bedata.flags = flags;
}
-bool EmergeManager::popBlockEmergeData(
- v3s16 pos,
- BlockEmergeData *bedata)
+bool EmergeManager::popBlockEmergeData(v3s16 pos, BlockEmergeData *bedata)
{
std::map<v3s16, BlockEmergeData>::iterator it;
- std::map<u16, u16>::iterator it2;
+ UNORDERED_MAP<u16, u16>::iterator it2;
it = m_blocks_enqueued.find(pos);
if (it == m_blocks_enqueued.end())
// 1). Attempt to fetch block from memory
*block = m_map->getBlockNoCreateNoEx(pos);
- if (*block && !(*block)->isDummy() && (*block)->isGenerated())
- return EMERGE_FROM_MEMORY;
-
- // 2). Attempt to load block from disk
- *block = m_map->loadBlock(pos);
- if (*block && (*block)->isGenerated())
- return EMERGE_FROM_DISK;
+ if (*block && !(*block)->isDummy()) {
+ if ((*block)->isGenerated())
+ return EMERGE_FROM_MEMORY;
+ } else {
+ // 2). Attempt to load block from disk if it was not in the memory
+ *block = m_map->loadBlock(pos);
+ if (*block && (*block)->isGenerated())
+ return EMERGE_FROM_DISK;
+ }
// 3). Attempt to start generation
if (allow_gen && m_map->initBlockMake(pos, bmdata))
m_server->getScriptIface()->environment_OnGenerated(
minp, maxp, m_mapgen->blockseed);
} catch (LuaError &e) {
- m_server->setAsyncFatalError("Lua: " + std::string(e.what()));
+ m_server->setAsyncFatalError("Lua: finishGen" + std::string(e.what()));
}
EMERGE_DBG_OUT("ended up with: " << analyze_block(block));
projects / minetest.git / blobdiff