core.registered_on_chat_messages, core.register_on_chat_message = make_registration()
core.registered_globalsteps, core.register_globalstep = make_registration()
core.registered_playerevents, core.register_playerevent = make_registration()
-core.registered_on_mapgen_inits, core.register_on_mapgen_init = make_registration()
core.registered_on_shutdown, core.register_on_shutdown = make_registration()
core.registered_on_punchnodes, core.register_on_punchnode = make_registration()
core.registered_on_placenodes, core.register_on_placenode = make_registration()
core.registered_on_protection_violation, core.register_on_protection_violation = make_registration()
core.registered_on_item_eats, core.register_on_item_eat = make_registration()
+--
+-- Compatibility for on_mapgen_init()
+--
+
+core.register_on_mapgen_init = function(func) func(core.get_mapgen_params()) end
+
^ Newest functions are called first
^ If function returns true, remaining functions are not called
minetest.register_on_mapgen_init(func(MapgenParams))
-^ Called just before the map generator is initialized but before the environment is initialized
-^ MapgenParams consists of a table with the fields mgname, seed, water_level, and flags
+^ Deprecated; maintained for compatibility
+^ This immediately calls func(minetest.get_mapgen_params())
+^ MapgenParams consists of a table with the fields mgname, chunksize, seed, water_level, and flags
minetest.register_on_craft(func(itemstack, player, old_craft_grid, craft_inv))
^ Called when player crafts something
^ itemstack is the output
^ The second parameter is a list of IDS of decorations which notification is requested for
minetest.get_mapgen_object(objectname)
^ Return requested mapgen object if available (see Mapgen objects)
+minetest.get_mapgen_params()
+^ Returns mapgen params
+^ A table consisting of mgname, seed, chunksize, water_level, and flags
+^ Can be called at any time
minetest.set_mapgen_params(MapgenParams)
^ Set map generation parameters
^ Function cannot be called after the registration period; only initialization and on_mapgen_init
/////////////////////////////// Emerge Manager ////////////////////////////////
-EmergeManager::EmergeManager(IGameDef *gamedef) {
+EmergeManager::EmergeManager(IGameDef *gamedef)
+{
//register built-in mapgens
registerMapgen("v5", new MapgenFactoryV5());
registerMapgen("v6", new MapgenFactoryV6());
}
-EmergeManager::~EmergeManager() {
+EmergeManager::~EmergeManager()
+{
for (unsigned int i = 0; i != emergethread.size(); i++) {
if (threads_active) {
emergethread[i]->Stop();
}
-void EmergeManager::loadMapgenParams() {
+void EmergeManager::loadMapgenParams()
+{
loadParamsFromSettings(g_settings);
if (g_settings->get("fixed_map_seed").empty()) {
}
-void EmergeManager::initMapgens() {
+void EmergeManager::initMapgens()
+{
if (mapgen.size())
return;
}
-Mapgen *EmergeManager::getCurrentMapgen() {
+Mapgen *EmergeManager::getCurrentMapgen()
+{
for (unsigned int i = 0; i != emergethread.size(); i++) {
if (emergethread[i]->IsSameThread())
return emergethread[i]->mapgen;
}
-void EmergeManager::startThreads() {
+void EmergeManager::startThreads()
+{
if (threads_active)
return;
}
-void EmergeManager::stopThreads() {
+void EmergeManager::stopThreads()
+{
if (!threads_active)
return;
}
-bool EmergeManager::enqueueBlockEmerge(u16 peer_id, v3s16 p, bool allow_generate) {
+bool EmergeManager::enqueueBlockEmerge(u16 peer_id, v3s16 p, bool allow_generate)
+{
std::map<v3s16, BlockEmergeData *>::const_iterator iter;
BlockEmergeData *bedata;
u16 count;
}
-int EmergeManager::getGroundLevelAtPoint(v2s16 p) {
+int EmergeManager::getGroundLevelAtPoint(v2s16 p)
+{
if (mapgen.size() == 0 || !mapgen[0]) {
errorstream << "EmergeManager: getGroundLevelAtPoint() called"
" before mapgen initialized" << std::endl;
}
-bool EmergeManager::isBlockUnderground(v3s16 blockpos) {
+bool EmergeManager::isBlockUnderground(v3s16 blockpos)
+{
/*
v2s16 p = v2s16((blockpos.X * MAP_BLOCKSIZE) + MAP_BLOCKSIZE / 2,
(blockpos.Y * MAP_BLOCKSIZE) + MAP_BLOCKSIZE / 2);
}
-u32 EmergeManager::getBlockSeed(v3s16 p) {
+u32 EmergeManager::getBlockSeed(v3s16 p)
+{
return (u32)(params.seed & 0xFFFFFFFF) +
p.Z * 38134234 +
p.Y * 42123 +
Mapgen *EmergeManager::createMapgen(std::string mgname, int mgid,
- MapgenParams *mgparams) {
+ MapgenParams *mgparams)
+{
std::map<std::string, MapgenFactory *>::const_iterator iter;
iter = mglist.find(mgname);
if (iter == mglist.end()) {
errorstream << "EmergeManager; mapgen " << mgname <<
- " not registered" << std::endl;
+ " not registered" << std::endl;
return NULL;
}
}
-MapgenSpecificParams *EmergeManager::createMapgenParams(std::string mgname) {
+MapgenSpecificParams *EmergeManager::createMapgenParams(std::string mgname)
+{
std::map<std::string, MapgenFactory *>::const_iterator iter;
iter = mglist.find(mgname);
if (iter == mglist.end()) {
errorstream << "EmergeManager: mapgen " << mgname <<
- " not registered" << std::endl;
+ " not registered" << std::endl;
return NULL;
}
}
-void EmergeManager::loadParamsFromSettings(Settings *settings) {
+void EmergeManager::loadParamsFromSettings(Settings *settings)
+{
std::string seed_str;
const char *setname = (settings == g_settings) ? "fixed_map_seed" : "seed";
}
-void EmergeManager::saveParamsToSettings(Settings *settings) {
+void EmergeManager::saveParamsToSettings(Settings *settings)
+{
settings->set("mg_name", params.mg_name);
settings->setU64("seed", params.seed);
settings->setS16("water_level", params.water_level);
}
-void EmergeManager::registerMapgen(std::string mgname, MapgenFactory *mgfactory) {
+void EmergeManager::registerMapgen(std::string mgname, MapgenFactory *mgfactory)
+{
mglist.insert(std::make_pair(mgname, mgfactory));
infostream << "EmergeManager: registered mapgen " << mgname << std::endl;
}
////////////////////////////// Emerge Thread //////////////////////////////////
-bool EmergeThread::popBlockEmerge(v3s16 *pos, u8 *flags) {
+bool EmergeThread::popBlockEmerge(v3s16 *pos, u8 *flags)
+{
std::map<v3s16, BlockEmergeData *>::iterator iter;
JMutexAutoLock queuelock(emerge->queuemutex);
bool EmergeThread::getBlockOrStartGen(v3s16 p, MapBlock **b,
- BlockMakeData *data, bool allow_gen) {
+ BlockMakeData *data, bool allow_gen)
+{
v2s16 p2d(p.X, p.Z);
//envlock: usually takes <=1ms, sometimes 90ms or ~400ms to acquire
JMutexAutoLock envlock(m_server->m_env_mutex);
}
-void *EmergeThread::Thread() {
+void *EmergeThread::Thread()
+{
ThreadStarted();
log_register_thread("EmergeThread" + itos(id));
DSTACK(__FUNCTION_NAME);
#include "mapgen.h" // for MapgenParams
#include "map.h"
-#define MGPARAMS_SET_MGNAME 1
-#define MGPARAMS_SET_SEED 2
-#define MGPARAMS_SET_WATER_LEVEL 4
-#define MGPARAMS_SET_FLAGS 8
-
#define BLOCK_EMERGE_ALLOWGEN (1<<0)
#define EMERGE_DBG_OUT(x) \
}
}
-void ScriptApiEnv::environment_OnMapgenInit(MapgenParams *mgparams)
-{
- SCRIPTAPI_PRECHECKHEADER
-
- // Get core.registered_on_mapgen_inits
- lua_getglobal(L, "core");
- lua_getfield(L, -1, "registered_on_mapgen_inits");
-
- // Call callbacks
- lua_newtable(L);
-
- lua_pushstring(L, mgparams->mg_name.c_str());
- lua_setfield(L, -2, "mgname");
-
- lua_pushinteger(L, mgparams->seed);
- lua_setfield(L, -2, "seed");
-
- lua_pushinteger(L, mgparams->water_level);
- lua_setfield(L, -2, "water_level");
-
- lua_pushinteger(L, mgparams->chunksize);
- lua_setfield(L, -2, "chunksize");
-
- std::string flagstr = writeFlagString(mgparams->flags,
- flagdesc_mapgen, (u32)-1);
- lua_pushstring(L, flagstr.c_str());
- lua_setfield(L, -2, "flags");
-
- script_run_callbacks(L, 1, RUN_CALLBACKS_MODE_FIRST);
-}
-
void ScriptApiEnv::initializeEnvironment(ServerEnvironment *env)
{
SCRIPTAPI_PRECHECKHEADER
void environment_Step(float dtime);
// After generating a piece of map
void environment_OnGenerated(v3s16 minp, v3s16 maxp,u32 blockseed);
- // After initializing mapgens
- void environment_OnMapgenInit(MapgenParams *mgparams);
//called on player event
void player_event(ServerActiveObject* player, std::string type);
return 0;
}
+int ModApiMapgen::l_get_mapgen_params(lua_State *L)
+{
+ MapgenParams *params = &getServer(L)->getEmergeManager()->params;
+
+ lua_newtable(L);
+
+ lua_pushstring(L, params->mg_name.c_str());
+ lua_setfield(L, -2, "mgname");
+
+ lua_pushinteger(L, params->seed);
+ lua_setfield(L, -2, "seed");
+
+ lua_pushinteger(L, params->water_level);
+ lua_setfield(L, -2, "water_level");
+
+ lua_pushinteger(L, params->chunksize);
+ lua_setfield(L, -2, "chunksize");
+
+ std::string flagstr = writeFlagString(params->flags, flagdesc_mapgen, (u32)-1);
+ lua_pushstring(L, flagstr.c_str());
+ lua_setfield(L, -2, "flags");
+
+ return 1;
+}
+
// set_mapgen_params(params)
// set mapgen parameters
int ModApiMapgen::l_set_mapgen_params(lua_State *L)
if (!lua_istable(L, 1))
return 0;
- EmergeManager *emerge = getServer(L)->getEmergeManager();
- assert(emerge);
-
- std::string flagstr;
+ MapgenParams *params = &getServer(L)->getEmergeManager()->params;
u32 flags = 0, flagmask = 0;
lua_getfield(L, 1, "mgname");
if (lua_isstring(L, -1)) {
- emerge->params.mg_name = std::string(lua_tostring(L, -1));
- delete emerge->params.sparams;
- emerge->params.sparams = NULL;
+ params->mg_name = lua_tostring(L, -1);
+ delete params->sparams;
+ params->sparams = NULL;
}
lua_getfield(L, 1, "seed");
if (lua_isnumber(L, -1))
- emerge->params.seed = lua_tointeger(L, -1);
+ params->seed = lua_tointeger(L, -1);
lua_getfield(L, 1, "water_level");
if (lua_isnumber(L, -1))
- emerge->params.water_level = lua_tointeger(L, -1);
+ params->water_level = lua_tointeger(L, -1);
lua_getfield(L, 1, "flagmask");
if (lua_isstring(L, -1)) {
- flagstr = lua_tostring(L, -1);
- emerge->params.flags &= ~readFlagString(flagstr, flagdesc_mapgen, NULL);
+ params->flags &= ~readFlagString(lua_tostring(L, -1), flagdesc_mapgen, NULL);
errorstream << "set_mapgen_params(): flagmask field is deprecated, "
"see lua_api.txt" << std::endl;
}
if (getflagsfield(L, 1, "flags", flagdesc_mapgen, &flags, &flagmask)) {
- emerge->params.flags &= ~flagmask;
- emerge->params.flags |= flags;
+ params->flags &= ~flagmask;
+ params->flags |= flags;
}
return 0;
{
API_FCT(get_mapgen_object);
+ API_FCT(get_mapgen_params);
API_FCT(set_mapgen_params);
API_FCT(set_noiseparams);
API_FCT(set_gen_notify);
// returns the requested object used during map generation
static int l_get_mapgen_object(lua_State *L);
+ // get_mapgen_params()
+ // returns the currently active map generation parameter set
+ static int l_get_mapgen_params(lua_State *L);
+
// set_mapgen_params(params)
// set mapgen parameters
static int l_set_mapgen_params(lua_State *L);
// Lock environment
JMutexAutoLock envlock(m_env_mutex);
+ // Create the Map and load parameters
+ ServerMap *servermap = new ServerMap(path_world, this, m_emerge);
+ m_emerge->loadMapgenParams();
+
// Initialize scripting
infostream<<"Server: Initializing Lua"<<std::endl;
std::string scriptpath = getBuiltinLuaPath() + DIR_DELIM "init.lua";
- if (!m_script->loadScript(scriptpath)) {
+ if (!m_script->loadScript(scriptpath))
throw ModError("Failed to load and run " + scriptpath);
- }
-
// Print 'em
infostream<<"Server: Loading mods: ";
// Perform pending node name resolutions
m_nodedef->runNodeResolverCallbacks();
- // Load the mapgen params from global settings now after any
- // initial overrides have been set by the mods
- m_emerge->loadMapgenParams();
-
// Initialize Environment
- ServerMap *servermap = new ServerMap(path_world, this, m_emerge);
m_env = new ServerEnvironment(servermap, m_script, this, m_path_world);
m_clients.setEnv(m_env);
- // Run some callbacks after the MG params have been set up but before activation
- m_script->environment_OnMapgenInit(&m_emerge->params);
-
// Initialize mapgens
m_emerge->initMapgens();
projects / oweals / minetest.git / commitdiff