X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fenvironment.cpp;h=66898f012f3573fe032201b8fcf53ba8d08bb29b;hb=56195dc2e45b85b7177cfa97aade77e92cff8805;hp=93649eed5b532f1eeec2577ec5ee4d6745f43ecd;hpb=58bed83d03bbe53f8286640fbc33043800e1c318;p=oweals%2Fminetest.git diff --git a/src/environment.cpp b/src/environment.cpp index 93649eed5..66898f012 100644 --- a/src/environment.cpp +++ b/src/environment.cpp @@ -1,25 +1,22 @@ /* -Minetest-c55 -Copyright (C) 2010-2011 celeron55, Perttu Ahola +Minetest +Copyright (C) 2010-2013 celeron55, Perttu Ahola This program is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2 of the License, or +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. +GNU Lesser General Public License for more details. -You should have received a copy of the GNU General Public License along +You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#include -#include -#include #include "environment.h" #include "filesys.h" #include "porting.h" @@ -28,32 +25,42 @@ with this program; if not, write to the Free Software Foundation, Inc., #include "mapblock.h" #include "serverobject.h" #include "content_sao.h" -#include "mapgen.h" #include "settings.h" #include "log.h" #include "profiler.h" -#include "scriptapi.h" +#include "scripting_game.h" #include "nodedef.h" #include "nodemetadata.h" #include "main.h" // For g_settings, g_profiler #include "gamedef.h" -#include "serverremoteplayer.h" #ifndef SERVER #include "clientmap.h" +#include "localplayer.h" +#include "event.h" #endif +#include "daynightratio.h" +#include "map.h" +#include "emerge.h" +#include "util/serialize.h" +#include "jthread/jmutexautolock.h" #define PP(x) "("<<(x).X<<","<<(x).Y<<","<<(x).Z<<")" Environment::Environment(): - m_time_of_day(9000) + m_time_of_day(9000), + m_time_of_day_f(9000./24000), + m_time_of_day_speed(0), + m_time_counter(0), + m_enable_day_night_ratio_override(false), + m_day_night_ratio_override(0.0f) { } Environment::~Environment() { // Deallocate players - for(core::list::Iterator i = m_players.begin(); - i != m_players.end(); i++) + for(std::list::iterator i = m_players.begin(); + i != m_players.end(); ++i) { delete (*i); } @@ -79,26 +86,36 @@ void Environment::addPlayer(Player *player) void Environment::removePlayer(u16 peer_id) { DSTACK(__FUNCTION_NAME); -re_search: - for(core::list::Iterator i = m_players.begin(); - i != m_players.end(); i++) + + for(std::list::iterator i = m_players.begin(); + i != m_players.end();) { Player *player = *i; - if(player->peer_id != peer_id) - continue; - - delete player; - m_players.erase(i); - // See if there is an another one - // (shouldn't be, but just to be sure) - goto re_search; + if(player->peer_id == peer_id) { + delete player; + i = m_players.erase(i); + } else { + ++i; + } + } +} + +void Environment::removePlayer(const char *name) +{ + for (std::list::iterator it = m_players.begin(); + it != m_players.end(); ++it) { + if (strcmp((*it)->getName(), name) == 0) { + delete *it; + m_players.erase(it); + return; + } } } Player * Environment::getPlayer(u16 peer_id) { - for(core::list::Iterator i = m_players.begin(); - i != m_players.end(); i++) + for(std::list::iterator i = m_players.begin(); + i != m_players.end(); ++i) { Player *player = *i; if(player->peer_id == peer_id) @@ -109,8 +126,8 @@ Player * Environment::getPlayer(u16 peer_id) Player * Environment::getPlayer(const char *name) { - for(core::list::Iterator i = m_players.begin(); - i != m_players.end(); i++) + for(std::list::iterator i = m_players.begin(); + i != m_players.end(); ++i) { Player *player = *i; if(strcmp(player->getName(), name) == 0) @@ -121,12 +138,12 @@ Player * Environment::getPlayer(const char *name) Player * Environment::getRandomConnectedPlayer() { - core::list connected_players = getPlayers(true); + std::list connected_players = getPlayers(true); u32 chosen_one = myrand() % connected_players.size(); u32 j = 0; - for(core::list::Iterator + for(std::list::iterator i = connected_players.begin(); - i != connected_players.end(); i++) + i != connected_players.end(); ++i) { if(j == chosen_one) { @@ -140,12 +157,12 @@ Player * Environment::getRandomConnectedPlayer() Player * Environment::getNearestConnectedPlayer(v3f pos) { - core::list connected_players = getPlayers(true); + std::list connected_players = getPlayers(true); f32 nearest_d = 0; Player *nearest_player = NULL; - for(core::list::Iterator + for(std::list::iterator i = connected_players.begin(); - i != connected_players.end(); i++) + i != connected_players.end(); ++i) { Player *player = *i; f32 d = player->getPosition().getDistanceFrom(pos); @@ -158,17 +175,17 @@ Player * Environment::getNearestConnectedPlayer(v3f pos) return nearest_player; } -core::list Environment::getPlayers() +std::list Environment::getPlayers() { return m_players; } -core::list Environment::getPlayers(bool ignore_disconnected) +std::list Environment::getPlayers(bool ignore_disconnected) { - core::list newlist; - for(core::list::Iterator + std::list newlist; + for(std::list::iterator i = m_players.begin(); - i != m_players.end(); i++) + i != m_players.end(); ++i) { Player *player = *i; @@ -184,26 +201,57 @@ core::list Environment::getPlayers(bool ignore_disconnected) return newlist; } -void Environment::printPlayers(std::ostream &o) +u32 Environment::getDayNightRatio() { - o<<"Players in environment:"<::Iterator i = m_players.begin(); - i != m_players.end(); i++) - { - Player *player = *i; - o<<"Player peer_id="<peer_id<getBool("enable_shaders"); + return time_to_daynight_ratio(m_time_of_day_f*24000, smooth); } -/*void Environment::setDayNightRatio(u32 r) +void Environment::setTimeOfDaySpeed(float speed) { - getDayNightRatio() = r; -}*/ + JMutexAutoLock(this->m_lock); + m_time_of_day_speed = speed; +} -u32 Environment::getDayNightRatio() +float Environment::getTimeOfDaySpeed() { - //return getDayNightRatio(); - return time_to_daynight_ratio(m_time_of_day); + JMutexAutoLock(this->m_lock); + float retval = m_time_of_day_speed; + return retval; +} + +void Environment::stepTimeOfDay(float dtime) +{ + float day_speed = 0; + { + JMutexAutoLock(this->m_lock); + day_speed = m_time_of_day_speed; + } + + m_time_counter += dtime; + f32 speed = day_speed * 24000./(24.*3600); + u32 units = (u32)(m_time_counter*speed); + bool sync_f = false; + if(units > 0){ + // Sync at overflow + if(m_time_of_day + units >= 24000) + sync_f = true; + m_time_of_day = (m_time_of_day + units) % 24000; + if(sync_f) + m_time_of_day_f = (float)m_time_of_day / 24000.0; + } + if (speed > 0) { + m_time_counter -= (f32)units / speed; + } + if(!sync_f){ + m_time_of_day_f += day_speed/24/3600*dtime; + if(m_time_of_day_f > 1.0) + m_time_of_day_f -= 1.0; + if(m_time_of_day_f < 0.0) + m_time_of_day_f += 1.0; + } } /* @@ -226,7 +274,7 @@ ABMWithState::ABMWithState(ActiveBlockModifier *abm_): ActiveBlockList */ -void fillRadiusBlock(v3s16 p0, s16 r, core::map &list) +void fillRadiusBlock(v3s16 p0, s16 r, std::set &list) { v3s16 p; for(p.X=p0.X-r; p.X<=p0.X+r; p.X++) @@ -234,21 +282,21 @@ void fillRadiusBlock(v3s16 p0, s16 r, core::map &list) for(p.Z=p0.Z-r; p.Z<=p0.Z+r; p.Z++) { // Set in list - list[p] = true; + list.insert(p); } } -void ActiveBlockList::update(core::list &active_positions, +void ActiveBlockList::update(std::list &active_positions, s16 radius, - core::map &blocks_removed, - core::map &blocks_added) + std::set &blocks_removed, + std::set &blocks_added) { /* Create the new list */ - core::map newlist; - for(core::list::Iterator i = active_positions.begin(); - i != active_positions.end(); i++) + std::set newlist = m_forceloaded_list; + for(std::list::iterator i = active_positions.begin(); + i != active_positions.end(); ++i) { fillRadiusBlock(*i, radius, newlist); } @@ -257,37 +305,37 @@ void ActiveBlockList::update(core::list &active_positions, Find out which blocks on the old list are not on the new list */ // Go through old list - for(core::map::Iterator i = m_list.getIterator(); - i.atEnd()==false; i++) + for(std::set::iterator i = m_list.begin(); + i != m_list.end(); ++i) { - v3s16 p = i.getNode()->getKey(); + v3s16 p = *i; // If not on new list, it's been removed - if(newlist.find(p) == NULL) - blocks_removed.insert(p, true); + if(newlist.find(p) == newlist.end()) + blocks_removed.insert(p); } /* Find out which blocks on the new list are not on the old list */ // Go through new list - for(core::map::Iterator i = newlist.getIterator(); - i.atEnd()==false; i++) + for(std::set::iterator i = newlist.begin(); + i != newlist.end(); ++i) { - v3s16 p = i.getNode()->getKey(); + v3s16 p = *i; // If not on old list, it's been added - if(m_list.find(p) == NULL) - blocks_added.insert(p, true); + if(m_list.find(p) == m_list.end()) + blocks_added.insert(p); } /* Update m_list */ m_list.clear(); - for(core::map::Iterator i = newlist.getIterator(); - i.atEnd()==false; i++) + for(std::set::iterator i = newlist.begin(); + i != newlist.end(); ++i) { - v3s16 p = i.getNode()->getKey(); - m_list.insert(p, true); + v3s16 p = *i; + m_list.insert(p); } } @@ -295,16 +343,19 @@ void ActiveBlockList::update(core::list &active_positions, ServerEnvironment */ -ServerEnvironment::ServerEnvironment(ServerMap *map, lua_State *L, - IGameDef *gamedef, IBackgroundBlockEmerger *emerger): +ServerEnvironment::ServerEnvironment(ServerMap *map, + GameScripting *scriptIface, IGameDef *gamedef, + const std::string &path_world) : m_map(map), - m_lua(L), + m_script(scriptIface), m_gamedef(gamedef), - m_emerger(emerger), - m_random_spawn_timer(3), + m_path_world(path_world), m_send_recommended_timer(0), + m_active_block_interval_overload_skip(0), m_game_time(0), - m_game_time_fraction_counter(0) + m_game_time_fraction_counter(0), + m_recommended_send_interval(0.1), + m_max_lag_estimate(0.1) { } @@ -321,260 +372,165 @@ ServerEnvironment::~ServerEnvironment() m_map->drop(); // Delete ActiveBlockModifiers - for(core::list::Iterator - i = m_abms.begin(); i != m_abms.end(); i++){ + for(std::list::iterator + i = m_abms.begin(); i != m_abms.end(); ++i){ delete i->abm; } } -void ServerEnvironment::serializePlayers(const std::string &savedir) +Map & ServerEnvironment::getMap() { - std::string players_path = savedir + "/players"; - fs::CreateDir(players_path); + return *m_map; +} - core::map saved_players; +ServerMap & ServerEnvironment::getServerMap() +{ + return *m_map; +} - std::vector player_files = fs::GetDirListing(players_path); - for(u32 i=0; iserialize(os); - saved_players.insert(player, true); + return false; } } + return true; +} - for(core::list::Iterator i = m_players.begin(); - i != m_players.end(); i++) - { - Player *player = *i; - if(saved_players.find(player) != NULL) - { - /*infostream<<"Player "<getName() - <<" was already saved."<getName(); - // Don't save unnamed player - if(playername == "") - { - //infostream<<"Not saving unnamed player."<getName()<<" to " - <serialize(os); - saved_players.insert(player, true); + for (std::list::iterator it = m_players.begin(); + it != m_players.end(); + ++it) { + RemotePlayer *player = static_cast(*it); + if (player->checkModified()) { + player->save(players_path); } } - - //infostream<<"Saved "< saved_players; - - std::vector player_files = fs::GetDirListing(players_path); - for(u32 i=0; i(player); + RemotePlayer *player = static_cast(getPlayer(playername.c_str())); + if (player) { + player->save(players_path); + } +} - // Load player - { - verbosestream<<"Reading player "<deSerialize(is); - srp->m_last_good_position = srp->getBasePosition(); - srp->m_last_good_position_age = 0; +Player *ServerEnvironment::loadPlayer(const std::string &playername) +{ + std::string players_path = m_path_world + DIR_DELIM "players" DIR_DELIM; + + RemotePlayer *player = static_cast(getPlayer(playername.c_str())); + bool newplayer = false; + bool found = false; + if (!player) { + player = new RemotePlayer(m_gamedef); + newplayer = true; + } + + RemotePlayer testplayer(m_gamedef); + std::string path = players_path + playername; + for (u32 i = 0; i < PLAYER_FILE_ALTERNATE_TRIES; i++) { + // Open file and deserialize + std::ifstream is(path.c_str(), std::ios_base::binary); + if (!is.good()) { + return NULL; } - - if(newplayer) - { - addPlayer(player); + testplayer.deSerialize(is, path); + is.close(); + if (testplayer.getName() == playername) { + *player = testplayer; + found = true; + break; } + path = players_path + playername + itos(i); } + if (!found) { + infostream << "Player file for player " << playername + << " not found" << std::endl; + return NULL; + } + if (newplayer) { + addPlayer(player); + } + return player; } -void ServerEnvironment::saveMeta(const std::string &savedir) +void ServerEnvironment::saveMeta() { - std::string path = savedir + "/env_meta.txt"; + std::string path = m_path_world + DIR_DELIM "env_meta.txt"; // Open file and serialize - std::ofstream os(path.c_str(), std::ios_base::binary); - if(os.good() == false) - { - infostream<<"ServerEnvironment::saveMeta(): Failed to open " - < > m_aabms; public: - ABMHandler(core::list &abms, + ABMHandler(std::list &abms, float dtime_s, ServerEnvironment *env, bool use_timers): m_env(env) @@ -601,8 +557,8 @@ public: if(dtime_s < 0.001) return; INodeDefManager *ndef = env->getGameDef()->ndef(); - for(core::list::Iterator - i = abms.begin(); i != abms.end(); i++){ + for(std::list::iterator + i = abms.begin(); i != abms.end(); ++i){ ActiveBlockModifier *abm = i->abm; float trigger_interval = abm->getTriggerInterval(); if(trigger_interval < 0.001) @@ -615,13 +571,15 @@ public: i->timer -= trigger_interval; actual_interval = trigger_interval; } - ActiveABM aabm; - aabm.abm = abm; float intervals = actual_interval / trigger_interval; + if(intervals == 0) + continue; float chance = abm->getTriggerChance(); if(chance == 0) chance = 1; - aabm.chance = 1.0 / pow((float)1.0/chance, (float)intervals); + ActiveABM aabm; + aabm.abm = abm; + aabm.chance = chance / intervals; if(aabm.chance == 0) aabm.chance = 1; // Trigger neighbors @@ -629,30 +587,61 @@ public: = abm->getRequiredNeighbors(); for(std::set::iterator i = required_neighbors_s.begin(); - i != required_neighbors_s.end(); i++){ - content_t c = ndef->getId(*i); - if(c == CONTENT_IGNORE) - continue; - aabm.required_neighbors.insert(c); + i != required_neighbors_s.end(); i++) + { + ndef->getIds(*i, aabm.required_neighbors); } // Trigger contents std::set contents_s = abm->getTriggerContents(); for(std::set::iterator - i = contents_s.begin(); i != contents_s.end(); i++){ - content_t c = ndef->getId(*i); - if(c == CONTENT_IGNORE) - continue; - std::map >::iterator j; - j = m_aabms.find(c); - if(j == m_aabms.end()){ - std::list aabmlist; - m_aabms[c] = aabmlist; + i = contents_s.begin(); i != contents_s.end(); i++) + { + std::set ids; + ndef->getIds(*i, ids); + for(std::set::const_iterator k = ids.begin(); + k != ids.end(); k++) + { + content_t c = *k; + std::map >::iterator j; j = m_aabms.find(c); + if(j == m_aabms.end()){ + std::list aabmlist; + m_aabms[c] = aabmlist; + j = m_aabms.find(c); + } + j->second.push_back(aabm); } - j->second.push_back(aabm); } } } + // Find out how many objects the given block and its neighbours contain. + // Returns the number of objects in the block, and also in 'wider' the + // number of objects in the block and all its neighbours. The latter + // may an estimate if any neighbours are unloaded. + u32 countObjects(MapBlock *block, ServerMap * map, u32 &wider) + { + wider = 0; + u32 wider_unknown_count = 0; + for(s16 x=-1; x<=1; x++) + for(s16 y=-1; y<=1; y++) + for(s16 z=-1; z<=1; z++) + { + MapBlock *block2 = map->getBlockNoCreateNoEx( + block->getPos() + v3s16(x,y,z)); + if(block2==NULL){ + wider_unknown_count++; + continue; + } + wider += block2->m_static_objects.m_active.size() + + block2->m_static_objects.m_stored.size(); + } + // Extrapolate + u32 active_object_count = block->m_static_objects.m_active.size(); + u32 wider_known_count = 3*3*3 - wider_unknown_count; + wider += wider_unknown_count * wider / wider_known_count; + return active_object_count; + + } void apply(MapBlock *block) { if(m_aabms.empty()) @@ -660,6 +649,10 @@ public: ServerMap *map = &m_env->getServerMap(); + u32 active_object_count_wider; + u32 active_object_count = this->countObjects(block, map, active_object_count_wider); + m_env->m_added_objects = 0; + v3s16 p0; for(p0.X=0; p0.Xm_static_objects.m_active.size(); - // Find out how many objects this and all the neighbors contain - u32 active_object_count_wider = 0; - for(s16 x=-1; x<=1; x++) - for(s16 y=-1; y<=1; y++) - for(s16 z=-1; z<=1; z++) - { - MapBlock *block2 = map->getBlockNoCreateNoEx( - block->getPos() + v3s16(x,y,z)); - if(block2==NULL) - continue; - active_object_count_wider += - block2->m_static_objects.m_active.size() - + block2->m_static_objects.m_stored.size(); - } - // Call all the trigger variations i->abm->trigger(m_env, p, n); i->abm->trigger(m_env, p, n, active_object_count, active_object_count_wider); + + // Count surrounding objects again if the abms added any + if(m_env->m_added_objects > 0) { + active_object_count = countObjects(block, map, active_object_count_wider); + m_env->m_added_objects = 0; + } } } } @@ -731,6 +713,14 @@ neighbor_found: void ServerEnvironment::activateBlock(MapBlock *block, u32 additional_dtime) { + // Reset usage timer immediately, otherwise a block that becomes active + // again at around the same time as it would normally be unloaded will + // get unloaded incorrectly. (I think this still leaves a small possibility + // of a race condition between this and server::AsyncRunStep, which only + // some kind of synchronisation will fix, but it at least reduces the window + // of opportunity for it to break from seconds to nanoseconds) + block->resetUsageTimer(); + // Get time difference u32 dtime_s = 0; u32 stamp = block->getTimestamp(); @@ -748,19 +738,21 @@ void ServerEnvironment::activateBlock(MapBlock *block, u32 additional_dtime) <m_node_metadata->step((float)dtime_s); - if(changed) - { - MapEditEvent event; - event.type = MEET_BLOCK_NODE_METADATA_CHANGED; - event.p = block->getPos(); - m_map->dispatchEvent(&event); - - block->raiseModified(MOD_STATE_WRITE_NEEDED, - "node metadata modified in activateBlock"); + activateObjects(block, dtime_s); + + // Run node timers + std::map elapsed_timers = + block->m_node_timers.step((float)dtime_s); + if(!elapsed_timers.empty()){ + MapNode n; + for(std::map::iterator + i = elapsed_timers.begin(); + i != elapsed_timers.end(); i++){ + n = block->getNodeNoEx(i->first); + v3s16 p = i->first + block->getPosRelative(); + if(m_script->node_on_timer(p,n,i->second.elapsed)) + block->setNodeTimer(i->first,NodeTimer(i->second.timeout,0)); + } } /* Handle ActiveBlockModifiers */ @@ -773,15 +765,78 @@ void ServerEnvironment::addActiveBlockModifier(ActiveBlockModifier *abm) m_abms.push_back(ABMWithState(abm)); } +bool ServerEnvironment::setNode(v3s16 p, const MapNode &n) +{ + INodeDefManager *ndef = m_gamedef->ndef(); + MapNode n_old = m_map->getNodeNoEx(p); + + // Call destructor + if (ndef->get(n_old).has_on_destruct) + m_script->node_on_destruct(p, n_old); + + // Replace node + if (!m_map->addNodeWithEvent(p, n)) + return false; + + // Update active VoxelManipulator if a mapgen thread + m_map->updateVManip(p); + + // Call post-destructor + if (ndef->get(n_old).has_after_destruct) + m_script->node_after_destruct(p, n_old); + + // Call constructor + if (ndef->get(n).has_on_construct) + m_script->node_on_construct(p, n); + + return true; +} + +bool ServerEnvironment::removeNode(v3s16 p) +{ + INodeDefManager *ndef = m_gamedef->ndef(); + MapNode n_old = m_map->getNodeNoEx(p); + + // Call destructor + if (ndef->get(n_old).has_on_destruct) + m_script->node_on_destruct(p, n_old); + + // Replace with air + // This is slightly optimized compared to addNodeWithEvent(air) + if (!m_map->removeNodeWithEvent(p)) + return false; + + // Update active VoxelManipulator if a mapgen thread + m_map->updateVManip(p); + + // Call post-destructor + if (ndef->get(n_old).has_after_destruct) + m_script->node_after_destruct(p, n_old); + + // Air doesn't require constructor + return true; +} + +bool ServerEnvironment::swapNode(v3s16 p, const MapNode &n) +{ + if (!m_map->addNodeWithEvent(p, n, false)) + return false; + + // Update active VoxelManipulator if a mapgen thread + m_map->updateVManip(p); + + return true; +} + std::set ServerEnvironment::getObjectsInsideRadius(v3f pos, float radius) { std::set objects; - for(core::map::Iterator - i = m_active_objects.getIterator(); - i.atEnd()==false; i++) + for(std::map::iterator + i = m_active_objects.begin(); + i != m_active_objects.end(); ++i) { - ServerActiveObject* obj = i.getNode()->getValue(); - u16 id = i.getNode()->getKey(); + ServerActiveObject* obj = i->second; + u16 id = i->first; v3f objectpos = obj->getBasePosition(); if(objectpos.getDistanceFrom(pos) > radius) continue; @@ -794,16 +849,15 @@ void ServerEnvironment::clearAllObjects() { infostream<<"ServerEnvironment::clearAllObjects(): " <<"Removing all active objects"< objects_to_remove; - for(core::map::Iterator - i = m_active_objects.getIterator(); - i.atEnd()==false; i++) + std::list objects_to_remove; + for(std::map::iterator + i = m_active_objects.begin(); + i != m_active_objects.end(); ++i) { - ServerActiveObject* obj = i.getNode()->getValue(); + ServerActiveObject* obj = i->second; if(obj->getType() == ACTIVEOBJECT_TYPE_PLAYER) continue; - u16 id = i.getNode()->getKey(); - v3f objectpos = obj->getBasePosition(); + u16 id = i->first; // Delete static object if block is loaded if(obj->m_static_exists){ MapBlock *block = m_map->getBlockNoCreateNoEx(obj->m_static_block); @@ -824,7 +878,7 @@ void ServerEnvironment::clearAllObjects() // Tell the object about removal obj->removingFromEnvironment(); // Deregister in scripting api - scriptapi_rm_object_reference(m_lua, obj); + m_script->removeObjectReference(obj); // Delete active object if(obj->environmentDeletes()) @@ -833,13 +887,23 @@ void ServerEnvironment::clearAllObjects() objects_to_remove.push_back(id); } // Remove references from m_active_objects - for(core::list::Iterator i = objects_to_remove.begin(); - i != objects_to_remove.end(); i++) + for(std::list::iterator i = objects_to_remove.begin(); + i != objects_to_remove.end(); ++i) { - m_active_objects.remove(*i); + m_active_objects.erase(*i); } - core::list loadable_blocks; + // Get list of loaded blocks + std::list loaded_blocks; + infostream<<"ServerEnvironment::clearAllObjects(): " + <<"Listing all loaded blocks"<listAllLoadedBlocks(loaded_blocks); + infostream<<"ServerEnvironment::clearAllObjects(): " + <<"Done listing all loaded blocks: " + < loadable_blocks; infostream<<"ServerEnvironment::clearAllObjects(): " <<"Listing all loadable blocks"<listAllLoadableBlocks(loadable_blocks); @@ -847,12 +911,26 @@ void ServerEnvironment::clearAllObjects() <<"Done listing all loadable blocks: " <::iterator i = loaded_blocks.begin(); + i != loaded_blocks.end(); ++i) + { + v3s16 p = *i; + MapBlock *block = m_map->getBlockNoCreateNoEx(p); + assert(block); + block->refGrab(); + } + + // Remove objects in all loadable blocks + u32 unload_interval = g_settings->getS32("max_clearobjects_extra_loaded_blocks"); + unload_interval = MYMAX(unload_interval, 1); u32 report_interval = loadable_blocks.size() / 10; u32 num_blocks_checked = 0; u32 num_blocks_cleared = 0; u32 num_objs_cleared = 0; - for(core::list::Iterator i = loadable_blocks.begin(); - i != loadable_blocks.end(); i++) + for(std::list::iterator i = loadable_blocks.begin(); + i != loadable_blocks.end(); ++i) { v3s16 p = *i; MapBlock *block = m_map->emergeBlock(p, false); @@ -873,7 +951,8 @@ void ServerEnvironment::clearAllObjects() } num_blocks_checked++; - if(num_blocks_checked % report_interval == 0){ + if(report_interval != 0 && + num_blocks_checked % report_interval == 0){ float percent = 100.0 * (float)num_blocks_checked / loadable_blocks.size(); infostream<<"ServerEnvironment::clearAllObjects(): " @@ -881,7 +960,22 @@ void ServerEnvironment::clearAllObjects() <<" in "<unloadUnreferencedBlocks(); + } + } + m_map->unloadUnreferencedBlocks(); + + // Drop references that were added above + for(std::list::iterator i = loaded_blocks.begin(); + i != loaded_blocks.end(); ++i) + { + v3s16 p = *i; + MapBlock *block = m_map->getBlockNoCreateNoEx(p); + assert(block); + block->refDrop(); } + infostream<<"ServerEnvironment::clearAllObjects(): " <<"Finished: Cleared "<getFloat("dedicated_server_step"); + /* Increment game time */ @@ -908,19 +1010,17 @@ void ServerEnvironment::step(float dtime) */ { ScopeProfiler sp(g_profiler, "SEnv: handle players avg", SPT_AVG); - for(core::list::Iterator i = m_players.begin(); - i != m_players.end(); i++) + for(std::list::iterator i = m_players.begin(); + i != m_players.end(); ++i) { Player *player = *i; // Ignore disconnected players if(player->peer_id == 0) continue; - - v3f playerpos = player->getPosition(); // Move - player->move(dtime, *m_map, 100*BS); + player->move(dtime, this, 100*BS); } } @@ -933,10 +1033,10 @@ void ServerEnvironment::step(float dtime) /* Get player block positions */ - core::list players_blockpos; - for(core::list::Iterator + std::list players_blockpos; + for(std::list::iterator i = m_players.begin(); - i != m_players.end(); i++) + i != m_players.end(); ++i) { Player *player = *i; // Ignore disconnected players @@ -951,8 +1051,8 @@ void ServerEnvironment::step(float dtime) Update list of active blocks, collecting changes */ const s16 active_block_range = g_settings->getS16("active_block_range"); - core::map blocks_removed; - core::map blocks_added; + std::set blocks_removed; + std::set blocks_added; m_active_blocks.update(players_blockpos, active_block_range, blocks_removed, blocks_added); @@ -963,14 +1063,14 @@ void ServerEnvironment::step(float dtime) // Convert active objects that are no more in active blocks to static deactivateFarObjects(false); - for(core::map::Iterator - i = blocks_removed.getIterator(); - i.atEnd()==false; i++) + for(std::set::iterator + i = blocks_removed.begin(); + i != blocks_removed.end(); ++i) { - v3s16 p = i.getNode()->getKey(); + v3s16 p = *i; - /*infostream<<"Server: Block ("<getBlockNoCreateNoEx(p); if(block==NULL) @@ -984,24 +1084,21 @@ void ServerEnvironment::step(float dtime) Handle added blocks */ - for(core::map::Iterator - i = blocks_added.getIterator(); - i.atEnd()==false; i++) + for(std::set::iterator + i = blocks_added.begin(); + i != blocks_added.end(); ++i) { - v3s16 p = i.getNode()->getKey(); - - /*infostream<<"Server: Block ("<getBlockNoCreateNoEx(p); + MapBlock *block = m_map->getBlockOrEmerge(p); if(block==NULL){ - // Block needs to be fetched first - m_emerger->queueBlockEmerge(p, false); - m_active_blocks.m_list.remove(p); + m_active_blocks.m_list.erase(p); continue; } activateBlock(block); + /* infostream<<"Server: Block " << PP(p) + << " became active"<::Iterator - i = m_active_blocks.m_list.getIterator(); - i.atEnd()==false; i++) + for(std::set::iterator + i = m_active_blocks.m_list.begin(); + i != m_active_blocks.m_list.end(); ++i) { - v3s16 p = i.getNode()->getKey(); + v3s16 p = *i; /*infostream<<"Server: Block ("<raiseModified(MOD_STATE_WRITE_AT_UNLOAD, "Timestamp older than 60s (step)"); - // Run node metadata - bool changed = block->m_node_metadata->step(dtime); - if(changed) - { - MapEditEvent event; - event.type = MEET_BLOCK_NODE_METADATA_CHANGED; - event.p = p; - m_map->dispatchEvent(&event); - - block->raiseModified(MOD_STATE_WRITE_NEEDED, - "node metadata modified in step"); + // Run node timers + std::map elapsed_timers = + block->m_node_timers.step((float)dtime); + if(!elapsed_timers.empty()){ + MapNode n; + for(std::map::iterator + i = elapsed_timers.begin(); + i != elapsed_timers.end(); i++){ + n = block->getNodeNoEx(i->first); + p = i->first + block->getPosRelative(); + if(m_script->node_on_timer(p,n,i->second.elapsed)) + block->setNodeTimer(i->first,NodeTimer(i->second.timeout,0)); + } } } } const float abm_interval = 1.0; if(m_active_block_modifier_interval.step(dtime, abm_interval)) - { + do{ // breakable + if(m_active_block_interval_overload_skip > 0){ + ScopeProfiler sp(g_profiler, "SEnv: ABM overload skips"); + m_active_block_interval_overload_skip--; + break; + } ScopeProfiler sp(g_profiler, "SEnv: modify in blocks avg /1s", SPT_AVG); TimeTaker timer("modify in active blocks"); // Initialize handling of ActiveBlockModifiers ABMHandler abmhandler(m_abms, abm_interval, this, true); - for(core::map::Iterator - i = m_active_blocks.m_list.getIterator(); - i.atEnd()==false; i++) + for(std::set::iterator + i = m_active_blocks.m_list.begin(); + i != m_active_blocks.m_list.end(); ++i) { - v3s16 p = i.getNode()->getKey(); + v3s16 p = *i; /*infostream<<"Server: Block ("<environment_Step(dtime); /* Step active objects @@ -1114,11 +1219,11 @@ void ServerEnvironment::step(float dtime) send_recommended = true; } - for(core::map::Iterator - i = m_active_objects.getIterator(); - i.atEnd()==false; i++) + for(std::map::iterator + i = m_active_objects.begin(); + i != m_active_objects.end(); ++i) { - ServerActiveObject* obj = i.getNode()->getValue(); + ServerActiveObject* obj = i->second; // Remove non-peaceful mobs on peaceful mode if(g_settings->getBool("only_peaceful_mobs")){ if(!obj->isPeaceful()) @@ -1130,7 +1235,7 @@ void ServerEnvironment::step(float dtime) // Step object obj->step(dtime, send_recommended); // Read messages from object - while(obj->m_messages_out.size() > 0) + while(!obj->m_messages_out.empty()) { m_active_object_messages.push_back( obj->m_messages_out.pop_front()); @@ -1153,57 +1258,53 @@ void ServerEnvironment::step(float dtime) ServerActiveObject* ServerEnvironment::getActiveObject(u16 id) { - core::map::Node *n; + std::map::iterator n; n = m_active_objects.find(id); - if(n == NULL) + if(n == m_active_objects.end()) return NULL; - return n->getValue(); + return n->second; } bool isFreeServerActiveObjectId(u16 id, - core::map &objects) + std::map &objects) { if(id == 0) return false; - - for(core::map::Iterator - i = objects.getIterator(); - i.atEnd()==false; i++) - { - if(i.getNode()->getKey() == id) - return false; - } - return true; + + return objects.find(id) == objects.end(); } u16 getFreeServerActiveObjectId( - core::map &objects) + std::map &objects) { - u16 new_id = 1; + //try to reuse id's as late as possible + static u16 last_used_id = 0; + u16 startid = last_used_id; for(;;) { - if(isFreeServerActiveObjectId(new_id, objects)) - return new_id; + last_used_id ++; + if(isFreeServerActiveObjectId(last_used_id, objects)) + return last_used_id; - if(new_id == 65535) + if(last_used_id == startid) return 0; - - new_id++; } } u16 ServerEnvironment::addActiveObject(ServerActiveObject *object) { assert(object); - u16 id = addActiveObjectRaw(object, true); + m_added_objects++; + u16 id = addActiveObjectRaw(object, true, 0); return id; } +#if 0 bool ServerEnvironment::addActiveObjectAsStatic(ServerActiveObject *obj) { assert(obj); - v3f objectpos = obj->getBasePosition(); + v3f objectpos = obj->getBasePosition(); // The block in which the object resides in v3s16 blockpos_o = getNodeBlockPos(floatToInt(objectpos, BS)); @@ -1241,14 +1342,15 @@ bool ServerEnvironment::addActiveObjectAsStatic(ServerActiveObject *obj) return succeeded; } +#endif /* Finds out what new objects have been added to inside a radius around a position */ void ServerEnvironment::getAddedActiveObjects(v3s16 pos, s16 radius, - core::map ¤t_objects, - core::map &added_objects) + std::set ¤t_objects, + std::set &added_objects) { v3f pos_f = intToFloat(pos, BS); f32 radius_f = radius * BS; @@ -1259,17 +1361,17 @@ void ServerEnvironment::getAddedActiveObjects(v3s16 pos, s16 radius, - discard objects that are found in current_objects. - add remaining objects to added_objects */ - for(core::map::Iterator - i = m_active_objects.getIterator(); - i.atEnd()==false; i++) + for(std::map::iterator + i = m_active_objects.begin(); + i != m_active_objects.end(); ++i) { - u16 id = i.getNode()->getKey(); + u16 id = i->first; // Get object - ServerActiveObject *object = i.getNode()->getValue(); + ServerActiveObject *object = i->second; if(object == NULL) continue; - // Discard if removed - if(object->m_removed) + // Discard if removed or deactivating + if(object->m_removed || object->m_pending_deactivation) continue; if(object->unlimitedTransferDistance() == false){ // Discard if too far @@ -1278,12 +1380,12 @@ void ServerEnvironment::getAddedActiveObjects(v3s16 pos, s16 radius, continue; } // Discard if already on current_objects - core::map::Node *n; + std::set::iterator n; n = current_objects.find(id); - if(n != NULL) + if(n != current_objects.end()) continue; // Add to added_objects - added_objects.insert(id, false); + added_objects.insert(id); } } @@ -1292,8 +1394,8 @@ void ServerEnvironment::getAddedActiveObjects(v3s16 pos, s16 radius, inside a radius around a position */ void ServerEnvironment::getRemovedActiveObjects(v3s16 pos, s16 radius, - core::map ¤t_objects, - core::map &removed_objects) + std::set ¤t_objects, + std::set &removed_objects) { v3f pos_f = intToFloat(pos, BS); f32 radius_f = radius * BS; @@ -1305,23 +1407,23 @@ void ServerEnvironment::getRemovedActiveObjects(v3s16 pos, s16 radius, - object has m_removed=true, or - object is too far away */ - for(core::map::Iterator - i = current_objects.getIterator(); - i.atEnd()==false; i++) + for(std::set::iterator + i = current_objects.begin(); + i != current_objects.end(); ++i) { - u16 id = i.getNode()->getKey(); + u16 id = *i; ServerActiveObject *object = getActiveObject(id); if(object == NULL){ infostream<<"ServerEnvironment::getRemovedActiveObjects():" <<" object in current_objects is NULL"<m_removed) + if(object->m_removed || object->m_pending_deactivation) { - removed_objects.insert(id, false); + removed_objects.insert(id); continue; } @@ -1333,7 +1435,7 @@ void ServerEnvironment::getRemovedActiveObjects(v3s16 pos, s16 radius, if(distance_f >= radius_f) { - removed_objects.insert(id, false); + removed_objects.insert(id); continue; } @@ -1343,10 +1445,12 @@ void ServerEnvironment::getRemovedActiveObjects(v3s16 pos, s16 radius, ActiveObjectMessage ServerEnvironment::getActiveObjectMessage() { - if(m_active_object_messages.size() == 0) + if(m_active_object_messages.empty()) return ActiveObjectMessage(0); - return m_active_object_messages.pop_front(); + ActiveObjectMessage message = m_active_object_messages.front(); + m_active_object_messages.pop_front(); + return message; } /* @@ -1354,7 +1458,7 @@ ActiveObjectMessage ServerEnvironment::getActiveObjectMessage() */ u16 ServerEnvironment::addActiveObjectRaw(ServerActiveObject *object, - bool set_changed) + bool set_changed, u32 dtime_s) { assert(object); if(object->getId() == 0){ @@ -1384,7 +1488,7 @@ u16 ServerEnvironment::addActiveObjectRaw(ServerActiveObject *object, /*infostream<<"ServerEnvironment::addActiveObjectRaw(): " <<"added (id="<getId()<<")"<getId(), object); + m_active_objects[object->getId()] = object; verbosestream<<"ServerEnvironment::addActiveObjectRaw(): " <<"Added id="<getId()<<"; there are now " @@ -1392,9 +1496,9 @@ u16 ServerEnvironment::addActiveObjectRaw(ServerActiveObject *object, <addObjectReference(object); // Post-initialize object - object->addedToEnvironment(); + object->addedToEnvironment(dtime_s); // Add static data to block if(object->isStaticAllowed()) @@ -1405,21 +1509,20 @@ u16 ServerEnvironment::addActiveObjectRaw(ServerActiveObject *object, StaticObject s_obj(object->getType(), objectpos, staticdata); // Add to the block where the object is located in v3s16 blockpos = getNodeBlockPos(floatToInt(objectpos, BS)); - MapBlock *block = m_map->getBlockNoCreateNoEx(blockpos); - if(block) - { - block->m_static_objects.m_active.insert(object->getId(), s_obj); + MapBlock *block = m_map->emergeBlock(blockpos); + if(block){ + block->m_static_objects.m_active[object->getId()] = s_obj; object->m_static_exists = true; object->m_static_block = blockpos; if(set_changed) - block->raiseModified(MOD_STATE_WRITE_NEEDED, + block->raiseModified(MOD_STATE_WRITE_NEEDED, "addActiveObjectRaw"); - } - else{ + } else { + v3s16 p = floatToInt(objectpos, BS); errorstream<<"ServerEnvironment::addActiveObjectRaw(): " - <<"could not find block for storing id="<getId() - <<" statically"< objects_to_remove; - for(core::map::Iterator - i = m_active_objects.getIterator(); - i.atEnd()==false; i++) + std::list objects_to_remove; + for(std::map::iterator + i = m_active_objects.begin(); + i != m_active_objects.end(); ++i) { - u16 id = i.getNode()->getKey(); - ServerActiveObject* obj = i.getNode()->getValue(); + u16 id = i->first; + ServerActiveObject* obj = i->second; // This shouldn't happen but check it if(obj == NULL) { @@ -1460,24 +1563,47 @@ void ServerEnvironment::removeRemovedObjects() */ if(obj->m_static_exists && obj->m_removed) { - MapBlock *block = m_map->emergeBlock(obj->m_static_block); - if(block) - { + MapBlock *block = m_map->emergeBlock(obj->m_static_block, false); + if (block) { block->m_static_objects.remove(id); block->raiseModified(MOD_STATE_WRITE_NEEDED, - "removeRemovedObjects"); + "removeRemovedObjects/remove"); obj->m_static_exists = false; + } else { + infostream<<"Failed to emerge block from which an object to " + <<"be removed was loaded from. id="< 0, don't actually remove. + // If m_known_by_count > 0, don't actually remove. On some future + // invocation this will be 0, which is when removal will continue. if(obj->m_known_by_count > 0) continue; - + + /* + Move static data from active to stored if not marked as removed + */ + if(obj->m_static_exists && !obj->m_removed){ + MapBlock *block = m_map->emergeBlock(obj->m_static_block, false); + if (block) { + std::map::iterator i = + block->m_static_objects.m_active.find(id); + if(i != block->m_static_objects.m_active.end()){ + block->m_static_objects.m_stored.push_back(i->second); + block->m_static_objects.m_active.erase(id); + block->raiseModified(MOD_STATE_WRITE_NEEDED, + "removeRemovedObjects/deactivate"); + } + } else { + infostream<<"Failed to emerge block from which an object to " + <<"be deactivated was loaded from. id="<removingFromEnvironment(); // Deregister in scripting api - scriptapi_rm_object_reference(m_lua, obj); + m_script->removeObjectReference(obj); // Delete if(obj->environmentDeletes()) @@ -1486,10 +1612,10 @@ void ServerEnvironment::removeRemovedObjects() objects_to_remove.push_back(id); } // Remove references from m_active_objects - for(core::list::Iterator i = objects_to_remove.begin(); - i != objects_to_remove.end(); i++) + for(std::list::iterator i = objects_to_remove.begin(); + i != objects_to_remove.end(); ++i) { - m_active_objects.remove(*i); + m_active_objects.erase(*i); } } @@ -1530,7 +1656,7 @@ static void print_hexdump(std::ostream &o, const std::string &data) /* Convert stored objects from blocks near the players to active. */ -void ServerEnvironment::activateObjects(MapBlock *block) +void ServerEnvironment::activateObjects(MapBlock *block, u32 dtime_s) { if(block==NULL) return; @@ -1541,7 +1667,7 @@ void ServerEnvironment::activateObjects(MapBlock *block) <<"activating objects of block "<getPos()) <<" ("<m_static_objects.m_stored.size() <<" objects)"<m_static_objects.m_stored.size() > 49); + bool large_amount = (block->m_static_objects.m_stored.size() > g_settings->getU16("max_objects_per_block")); if(large_amount){ errorstream<<"suspiciously large amount of objects detected: " <m_static_objects.m_stored.size()<<" in " @@ -1554,13 +1680,12 @@ void ServerEnvironment::activateObjects(MapBlock *block) "large amount of objects"); return; } - // A list for objects that couldn't be converted to static for some - // reason. They will be stored back. - core::list new_stored; - // Loop through stored static objects - for(core::list::Iterator + + // Activate stored objects + std::list new_stored; + for(std::list::iterator i = block->m_static_objects.m_stored.begin(); - i != block->m_static_objects.m_stored.end(); i++) + i != block->m_static_objects.m_stored.end(); ++i) { /*infostream<<"Server: Creating an active object from " <<"static data"<getStaticData(); + StaticObject s_obj(obj->getType(), objectpos, staticdata_new); + block->m_static_objects.insert(id, s_obj); + obj->m_static_block = blockpos_o; + block->raiseModified(MOD_STATE_WRITE_NEEDED, + "deactivateFarObjects: Static data moved in"); + + // Delete from block where object was located + block = m_map->emergeBlock(old_static_block, false); + if(!block){ + errorstream<<"ServerEnvironment::deactivateFarObjects(): " + <<"Could not delete object id="<m_static_objects.remove(id); + block->raiseModified(MOD_STATE_WRITE_NEEDED, + "deactivateFarObjects: Static data moved out"); + continue; + } + // If block is active, don't remove if(!force_delete && m_active_blocks.contains(blockpos_o)) continue; @@ -1669,10 +1850,10 @@ void ServerEnvironment::deactivateFarObjects(bool force_delete) MapBlock *block = m_map->emergeBlock(obj->m_static_block, false); - core::map::Node *n = + std::map::iterator n = block->m_static_objects.m_active.find(id); - if(n){ - StaticObject static_old = n->getValue(); + if(n != block->m_static_objects.m_active.end()){ + StaticObject static_old = n->second; float save_movem = obj->getMinimumSavedMovement(); @@ -1708,21 +1889,41 @@ void ServerEnvironment::deactivateFarObjects(bool force_delete) // Add to the block where the object is located in v3s16 blockpos = getNodeBlockPos(floatToInt(objectpos, BS)); // Get or generate the block - MapBlock *block = m_map->emergeBlock(blockpos); + MapBlock *block = NULL; + try{ + block = m_map->emergeBlock(blockpos); + } catch(InvalidPositionException &e){ + // Handled via NULL pointer + // NOTE: emergeBlock's failure is usually determined by it + // actually returning NULL + } if(block) { - if(block->m_static_objects.m_stored.size() >= 49){ + if(block->m_static_objects.m_stored.size() >= g_settings->getU16("max_objects_per_block")){ errorstream<<"ServerEnv: Trying to store id="<getId() <<" statically but block "<m_static_objects.m_stored.size() - <<" (over 49) objects." + <<" objects." <<" Forcing delete."<m_static_objects.insert(new_id, s_obj); + // If static counterpart already exists in target block, + // remove it first. + // This shouldn't happen because the object is removed from + // the previous block before this according to + // obj->m_static_block, but happens rarely for some unknown + // reason. Unsuccessful attempts have been made to find + // said reason. + if(id && block->m_static_objects.m_active.find(id) != block->m_static_objects.m_active.end()){ + infostream<<"ServerEnv: WARNING: Performing hack #83274" + <m_static_objects.remove(id); + } + // Store static data + u16 store_id = pending_delete ? id : 0; + block->m_static_objects.insert(store_id, s_obj); // Only mark block as modified if data changed considerably if(shall_be_written) @@ -1736,9 +1937,10 @@ void ServerEnvironment::deactivateFarObjects(bool force_delete) } else{ if(!force_delete){ + v3s16 p = floatToInt(objectpos, BS); errorstream<<"ServerEnv: Could not find or generate " <<"a block for storing id="<getId() - <<" statically"<removingFromEnvironment(); // Deregister in scripting api - scriptapi_rm_object_reference(m_lua, obj); + m_script->removeObjectReference(obj); // Delete active object if(obj->environmentDeletes()) @@ -1776,10 +1978,10 @@ void ServerEnvironment::deactivateFarObjects(bool force_delete) } // Remove references from m_active_objects - for(core::list::Iterator i = objects_to_remove.begin(); - i != objects_to_remove.end(); i++) + for(std::list::iterator i = objects_to_remove.begin(); + i != objects_to_remove.end(); ++i) { - m_active_objects.remove(*i); + m_active_objects.erase(*i); } } @@ -1801,20 +2003,22 @@ ClientEnvironment::ClientEnvironment(ClientMap *map, scene::ISceneManager *smgr, m_gamedef(gamedef), m_irr(irr) { + char zero = 0; + memset(m_attachements, zero, sizeof(m_attachements)); } ClientEnvironment::~ClientEnvironment() { // delete active objects - for(core::map::Iterator - i = m_active_objects.getIterator(); - i.atEnd()==false; i++) + for(std::map::iterator + i = m_active_objects.begin(); + i != m_active_objects.end(); ++i) { - delete i.getNode()->getValue(); + delete i->second; } - for(core::list::Iterator - i = m_simple_objects.begin(); i != m_simple_objects.end(); i++) + for(std::list::iterator + i = m_simple_objects.begin(); i != m_simple_objects.end(); ++i) { delete *i; } @@ -1847,8 +2051,8 @@ void ClientEnvironment::addPlayer(Player *player) LocalPlayer * ClientEnvironment::getLocalPlayer() { - for(core::list::Iterator i = m_players.begin(); - i != m_players.end(); i++) + for(std::list::iterator i = m_players.begin(); + i != m_players.end(); ++i) { Player *player = *i; if(player->isLocal()) @@ -1861,14 +2065,18 @@ void ClientEnvironment::step(float dtime) { DSTACK(__FUNCTION_NAME); + /* Step time of day */ + stepTimeOfDay(dtime); + // Get some settings - bool free_move = g_settings->getBool("free_move"); + bool fly_allowed = m_gamedef->checkLocalPrivilege("fly"); + bool free_move = fly_allowed && g_settings->getBool("free_move"); // Get local player LocalPlayer *lplayer = getLocalPlayer(); assert(lplayer); // collision info queue - core::list player_collisions; + std::list player_collisions; /* Get the speed the player is going @@ -1930,27 +2138,42 @@ void ClientEnvironment::step(float dtime) */ { - v3f lplayerpos = lplayer->getPosition(); - // Apply physics if(free_move == false && is_climbing == false) { // Gravity v3f speed = lplayer->getSpeed(); - if(lplayer->swimming_up == false) - speed.Y -= 9.81 * BS * dtime_part * 2; + if(lplayer->in_liquid == false) + speed.Y -= lplayer->movement_gravity * lplayer->physics_override_gravity * dtime_part * 2; - // Water resistance - if(lplayer->in_water_stable || lplayer->in_water) - { - f32 max_down = 2.0*BS; - if(speed.Y < -max_down) speed.Y = -max_down; + // Liquid floating / sinking + if(lplayer->in_liquid && !lplayer->swimming_vertical) + speed.Y -= lplayer->movement_liquid_sink * dtime_part * 2; - f32 max = 2.5*BS; - if(speed.getLength() > max) - { - speed = speed / speed.getLength() * max; - } + // Liquid resistance + if(lplayer->in_liquid_stable || lplayer->in_liquid) + { + // How much the node's viscosity blocks movement, ranges between 0 and 1 + // Should match the scale at which viscosity increase affects other liquid attributes + const f32 viscosity_factor = 0.3; + + v3f d_wanted = -speed / lplayer->movement_liquid_fluidity; + f32 dl = d_wanted.getLength(); + if(dl > lplayer->movement_liquid_fluidity_smooth) + dl = lplayer->movement_liquid_fluidity_smooth; + dl *= (lplayer->liquid_viscosity * viscosity_factor) + (1 - viscosity_factor); + + v3f d = d_wanted.normalize() * dl; + speed += d; + +#if 0 // old code + if(speed.X > lplayer->movement_liquid_fluidity + lplayer->movement_liquid_fluidity_smooth) speed.X -= lplayer->movement_liquid_fluidity_smooth; + if(speed.X < -lplayer->movement_liquid_fluidity - lplayer->movement_liquid_fluidity_smooth) speed.X += lplayer->movement_liquid_fluidity_smooth; + if(speed.Y > lplayer->movement_liquid_fluidity + lplayer->movement_liquid_fluidity_smooth) speed.Y -= lplayer->movement_liquid_fluidity_smooth; + if(speed.Y < -lplayer->movement_liquid_fluidity - lplayer->movement_liquid_fluidity_smooth) speed.Y += lplayer->movement_liquid_fluidity_smooth; + if(speed.Z > lplayer->movement_liquid_fluidity + lplayer->movement_liquid_fluidity_smooth) speed.Z -= lplayer->movement_liquid_fluidity_smooth; + if(speed.Z < -lplayer->movement_liquid_fluidity - lplayer->movement_liquid_fluidity_smooth) speed.Z += lplayer->movement_liquid_fluidity_smooth; +#endif } lplayer->setSpeed(speed); @@ -1960,7 +2183,7 @@ void ClientEnvironment::step(float dtime) Move the lplayer. This also does collision detection. */ - lplayer->move(dtime_part, *m_map, position_max_increment, + lplayer->move(dtime_part, this, position_max_increment, &player_collisions); } } @@ -1968,21 +2191,39 @@ void ClientEnvironment::step(float dtime) //std::cout<<"Looped "<::Iterator + for(std::list::iterator i = player_collisions.begin(); - i != player_collisions.end(); i++) + i != player_collisions.end(); ++i) { CollisionInfo &info = *i; - if(info.t == COLLISION_FALL) + v3f speed_diff = info.new_speed - info.old_speed;; + // Handle only fall damage + // (because otherwise walking against something in fast_move kills you) + if(speed_diff.Y < 0 || info.old_speed.Y >= 0) + continue; + // Get rid of other components + speed_diff.X = 0; + speed_diff.Z = 0; + f32 pre_factor = 1; // 1 hp per node/s + f32 tolerance = BS*14; // 5 without damage + f32 post_factor = 1; // 1 hp per node/s + if(info.type == COLLISION_NODE) { - //f32 tolerance = BS*10; // 2 without damage - f32 tolerance = BS*12; // 3 without damage - f32 factor = 1; - if(info.speed > tolerance) - { - f32 damage_f = (info.speed - tolerance)/BS*factor; - u16 damage = (u16)(damage_f+0.5); + const ContentFeatures &f = m_gamedef->ndef()-> + get(m_map->getNodeNoEx(info.node_p)); + // Determine fall damage multiplier + int addp = itemgroup_get(f.groups, "fall_damage_add_percent"); + pre_factor = 1.0 + (float)addp/100.0; + } + float speed = pre_factor * speed_diff.getLength(); + if(speed > tolerance) + { + f32 damage_f = (speed - tolerance)/BS * post_factor; + u16 damage = (u16)(damage_f+0.5); + if(damage != 0){ damageLocalPlayer(damage, true); + MtEvent *e = new SimpleTriggerEvent("PlayerFallingDamage"); + m_gamedef->event()->put(e); } } } @@ -2000,7 +2241,7 @@ void ClientEnvironment::step(float dtime) v3s16 p2 = floatToInt(pf + v3f(0, BS*0.8, 0), BS); MapNode n2 = m_map->getNodeNoEx(p2); v3s16 p3 = floatToInt(pf + v3f(0, BS*1.6, 0), BS); - MapNode n3 = m_map->getNodeNoEx(p2); + MapNode n3 = m_map->getNodeNoEx(p3); u32 damage_per_second = 0; damage_per_second = MYMAX(damage_per_second, @@ -2015,15 +2256,63 @@ void ClientEnvironment::step(float dtime) damageLocalPlayer(damage_per_second, true); } } - + + /* + Drowning + */ + if(m_drowning_interval.step(dtime, 2.0)) + { + v3f pf = lplayer->getPosition(); + + // head + v3s16 p = floatToInt(pf + v3f(0, BS*1.6, 0), BS); + MapNode n = m_map->getNodeNoEx(p); + ContentFeatures c = m_gamedef->ndef()->get(n); + u8 drowning_damage = c.drowning; + if(drowning_damage > 0 && lplayer->hp > 0){ + u16 breath = lplayer->getBreath(); + if(breath > 10){ + breath = 11; + } + if(breath > 0){ + breath -= 1; + } + lplayer->setBreath(breath); + updateLocalPlayerBreath(breath); + } + + if(lplayer->getBreath() == 0 && drowning_damage > 0){ + damageLocalPlayer(drowning_damage, true); + } + } + if(m_breathing_interval.step(dtime, 0.5)) + { + v3f pf = lplayer->getPosition(); + + // head + v3s16 p = floatToInt(pf + v3f(0, BS*1.6, 0), BS); + MapNode n = m_map->getNodeNoEx(p); + ContentFeatures c = m_gamedef->ndef()->get(n); + if (!lplayer->hp){ + lplayer->setBreath(11); + } + else if(c.drowning == 0){ + u16 breath = lplayer->getBreath(); + if(breath <= 10){ + breath += 1; + lplayer->setBreath(breath); + updateLocalPlayerBreath(breath); + } + } + } + /* Stuff that can be done in an arbitarily large dtime */ - for(core::list::Iterator i = m_players.begin(); - i != m_players.end(); i++) + for(std::list::iterator i = m_players.begin(); + i != m_players.end(); ++i) { Player *player = *i; - v3f playerpos = player->getPosition(); /* Handle non-local players @@ -2031,37 +2320,39 @@ void ClientEnvironment::step(float dtime) if(player->isLocal() == false) { // Move - player->move(dtime, *m_map, 100*BS); + player->move(dtime, this, 100*BS); } // Update lighting on all players on client - u8 light = LIGHT_MAX; + float light = 1.0; try{ // Get node at head v3s16 p = player->getLightPosition(); MapNode n = m_map->getNode(p); - light = n.getLightBlend(getDayNightRatio(), m_gamedef->ndef()); + light = n.getLightBlendF1((float)getDayNightRatio()/1000, m_gamedef->ndef()); } catch(InvalidPositionException &e){ - light = blend_light(getDayNightRatio(), LIGHT_SUN, 0); + light = blend_light_f1((float)getDayNightRatio()/1000, LIGHT_SUN, 0); } - player->updateLight(light); + player->light = light; } /* Step active objects and update lighting of them */ - for(core::map::Iterator - i = m_active_objects.getIterator(); - i.atEnd()==false; i++) + g_profiler->avg("CEnv: num of objects", m_active_objects.size()); + bool update_lighting = m_active_object_light_update_interval.step(dtime, 0.21); + for(std::map::iterator + i = m_active_objects.begin(); + i != m_active_objects.end(); ++i) { - ClientActiveObject* obj = i.getNode()->getValue(); + ClientActiveObject* obj = i->second; // Step object obj->step(dtime, this); - if(m_active_object_light_update_interval.step(dtime, 0.21)) + if(update_lighting) { // Update lighting u8 light = 0; @@ -2081,12 +2372,13 @@ void ClientEnvironment::step(float dtime) /* Step and handle simple objects */ - for(core::list::Iterator + g_profiler->avg("CEnv: num of simple objects", m_simple_objects.size()); + for(std::list::iterator i = m_simple_objects.begin(); i != m_simple_objects.end();) { ClientSimpleObject *simple = *i; - core::list::Iterator cur = i; - i++; + std::list::iterator cur = i; + ++i; simple->step(dtime); if(simple->m_to_be_removed){ delete simple; @@ -2102,42 +2394,36 @@ void ClientEnvironment::addSimpleObject(ClientSimpleObject *simple) ClientActiveObject* ClientEnvironment::getActiveObject(u16 id) { - core::map::Node *n; + std::map::iterator n; n = m_active_objects.find(id); - if(n == NULL) + if(n == m_active_objects.end()) return NULL; - return n->getValue(); + return n->second; } bool isFreeClientActiveObjectId(u16 id, - core::map &objects) + std::map &objects) { if(id == 0) return false; - - for(core::map::Iterator - i = objects.getIterator(); - i.atEnd()==false; i++) - { - if(i.getNode()->getKey() == id) - return false; - } - return true; + + return objects.find(id) == objects.end(); } u16 getFreeClientActiveObjectId( - core::map &objects) + std::map &objects) { - u16 new_id = 1; + //try to reuse id's as late as possible + static u16 last_used_id = 0; + u16 startid = last_used_id; for(;;) { - if(isFreeClientActiveObjectId(new_id, objects)) - return new_id; + last_used_id ++; + if(isFreeClientActiveObjectId(last_used_id, objects)) + return last_used_id; - if(new_id == 65535) + if(last_used_id == startid) return 0; - - new_id++; } } @@ -2165,7 +2451,7 @@ u16 ClientEnvironment::addActiveObject(ClientActiveObject *object) } infostream<<"ClientEnvironment::addActiveObject(): " <<"added (id="<getId()<<")"<getId(), object); + m_active_objects[object->getId()] = object; object->addToScene(m_smgr, m_texturesource, m_irr); { // Update lighting immediately u8 light = 0; @@ -2198,8 +2484,20 @@ void ClientEnvironment::addActiveObject(u16 id, u8 type, obj->setId(id); - obj->initialize(init_data); - + try + { + obj->initialize(init_data); + } + catch(SerializationError &e) + { + errorstream<<"ClientEnvironment::addActiveObject():" + <<" id="<removeFromScene(); + obj->removeFromScene(true); delete obj; - m_active_objects.remove(id); + m_active_objects.erase(id); } void ClientEnvironment::processActiveObjectMessage(u16 id, @@ -2230,7 +2528,18 @@ void ClientEnvironment::processActiveObjectMessage(u16 id, <processMessage(data); + try + { + obj->processMessage(data); + } + catch(SerializationError &e) + { + errorstream<<"ClientEnvironment::processActiveObjectMessage():" + <<" id="<