Refactor utf8_to_wide/wide_to_utf8 functions

[dragonfireclient.git] / src / emerge.cpp

diff --git a/src/emerge.cpp b/src/emerge.cpp
index 510e7590f575647c7077072fa8cac7306f3ed14b..e0dc5628e480c2ccaa7fcf32c989a99d7d36c1ba 100644 (file)
--- a/src/emerge.cpp
+++ b/src/emerge.cpp
@@ -42,7 +42,6 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "profiler.h"
 #include "scripting_server.h"
 #include "server.h"
-#include "serverobject.h"
 #include "settings.h"
 #include "voxel.h"
 
@@ -110,6 +109,28 @@ class MapEditEventAreaIgnorer
        VoxelArea *m_ignorevariable;
 };
 
+EmergeParams::~EmergeParams()
+{
+       infostream << "EmergeParams: destroying " << this << std::endl;
+       // Delete everything that was cloned on creation of EmergeParams
+       delete biomemgr;
+       delete oremgr;
+       delete decomgr;
+       delete schemmgr;
+}
+
+EmergeParams::EmergeParams(EmergeManager *parent, const BiomeManager *biomemgr,
+       const OreManager *oremgr, const DecorationManager *decomgr,
+       const SchematicManager *schemmgr) :
+       ndef(parent->ndef),
+       enable_mapgen_debug_info(parent->enable_mapgen_debug_info),
+       gen_notify_on(parent->gen_notify_on),
+       gen_notify_on_deco_ids(&parent->gen_notify_on_deco_ids),
+       biomemgr(biomemgr->clone()), oremgr(oremgr->clone()),
+       decomgr(decomgr->clone()), schemmgr(schemmgr->clone())
+{
+}
+
 ////
 //// EmergeManager
 ////
@@ -136,9 +157,9 @@ EmergeManager::EmergeManager(Server *server)
                nthreads = Thread::getNumberOfProcessors() - 2;
        if (nthreads < 1)
                nthreads = 1;
-       verbosestream << "Using " << nthreads << " emerge threads." << std::endl;
 
        m_qlimit_total = g_settings->getU16("emergequeue_limit_total");
+       // FIXME: these fallback values are probably not good
        if (!g_settings->getU16NoEx("emergequeue_limit_diskonly", m_qlimit_diskonly))
                m_qlimit_diskonly = nthreads * 5 + 1;
        if (!g_settings->getU16NoEx("emergequeue_limit_generate", m_qlimit_generate))
@@ -184,14 +205,48 @@ EmergeManager::~EmergeManager()
 }
 
 
+BiomeManager *EmergeManager::getWritableBiomeManager()
+{
+       FATAL_ERROR_IF(!m_mapgens.empty(),
+               "Writable managers can only be returned before mapgen init");
+       return biomemgr;
+}
+
+OreManager *EmergeManager::getWritableOreManager()
+{
+       FATAL_ERROR_IF(!m_mapgens.empty(),
+               "Writable managers can only be returned before mapgen init");
+       return oremgr;
+}
+
+DecorationManager *EmergeManager::getWritableDecorationManager()
+{
+       FATAL_ERROR_IF(!m_mapgens.empty(),
+               "Writable managers can only be returned before mapgen init");
+       return decomgr;
+}
+
+SchematicManager *EmergeManager::getWritableSchematicManager()
+{
+       FATAL_ERROR_IF(!m_mapgens.empty(),
+               "Writable managers can only be returned before mapgen init");
+       return schemmgr;
+}
+
+
 void EmergeManager::initMapgens(MapgenParams *params)
 {
        FATAL_ERROR_IF(!m_mapgens.empty(), "Mapgen already initialised.");
 
        mgparams = params;
 
-       for (u32 i = 0; i != m_threads.size(); i++)
-               m_mapgens.push_back(Mapgen::createMapgen(params->mgtype, params, this));
+       for (u32 i = 0; i != m_threads.size(); i++) {
+               EmergeParams *p = new EmergeParams(
+                       this, biomemgr, oremgr, decomgr, schemmgr);
+               infostream << "EmergeManager: Created params " << p
+                       << " for thread " << i << std::endl;
+               m_mapgens.push_back(Mapgen::createMapgen(params->mgtype, params, p));
+       }
 }
 
 
@@ -201,8 +256,9 @@ Mapgen *EmergeManager::getCurrentMapgen()
                return nullptr;
 
        for (u32 i = 0; i != m_threads.size(); i++) {
-               if (m_threads[i]->isCurrentThread())
-                       return m_threads[i]->m_mapgen;
+               EmergeThread *t = m_threads[i];
+               if (t->isRunning() && t->isCurrentThread())
+                       return t->m_mapgen;
        }
 
        return nullptr;
@@ -340,14 +396,7 @@ int EmergeManager::getGroundLevelAtPoint(v2s16 p)
 // TODO(hmmmm): Move this to ServerMap
 bool EmergeManager::isBlockUnderground(v3s16 blockpos)
 {
-#if 0
-       v2s16 p = v2s16((blockpos.X * MAP_BLOCKSIZE) + MAP_BLOCKSIZE / 2,
-                                       (blockpos.Y * MAP_BLOCKSIZE) + MAP_BLOCKSIZE / 2);
-       int ground_level = getGroundLevelAtPoint(p);
-       return blockpos.Y * (MAP_BLOCKSIZE + 1) <= min(water_level, ground_level);
-#endif
-
-       // Use a simple heuristic; the above method is wildly inaccurate anyway.
+       // Use a simple heuristic
        return blockpos.Y * (MAP_BLOCKSIZE + 1) <= mgparams->water_level;
 }
 
@@ -370,6 +419,10 @@ bool EmergeManager::pushBlockEmergeData(
                                m_qlimit_generate : m_qlimit_diskonly;
                        if (count_peer >= qlimit_peer)
                                return false;
+               } else {
+                       // limit block enqueue requests for active blocks to 1/2 of total
+                       if (count_peer * 2 >= m_qlimit_total)
+                               return false;
                }
        }
 
@@ -588,8 +641,7 @@ MapBlock *EmergeThread::finishGen(v3s16 pos, BlockMakeData *bmdata,
        /*
                Clear generate notifier events
        */
-       Mapgen *mg = m_emerge->getCurrentMapgen();
-       mg->gennotify.clearEvents();
+       m_mapgen->gennotify.clearEvents();
 
        EMERGE_DBG_OUT("ended up with: " << analyze_block(block));
 
@@ -637,12 +689,8 @@ void *EmergeThread::run()
                        {
                                ScopeProfiler sp(g_profiler,
                                        "EmergeThread: Mapgen::makeChunk", SPT_AVG);
-                               TimeTaker t("mapgen::make_block()");
 
                                m_mapgen->makeChunk(&bmdata);
-
-                               if (!enable_mapgen_debug_info)
-                                       t.stop(true); // Hide output
                        }
 
                        block = finishGen(pos, &bmdata, &modified_blocks);