{
// Add the lbm_def to the LBMContentMapping.
// Unknown names get added to the global NameIdMapping.
- INodeDefManager *nodedef = gamedef->ndef();
+ const NodeDefManager *nodedef = gamedef->ndef();
lbm_list.push_back(lbm_def);
void fillRadiusBlock(v3s16 p0, s16 r, std::set<v3s16> &list)
{
- const s16 r2 = r * r;
v3s16 p;
- for (p.X = p0.X - r; p.X <= p0.X + r; p.X++)
- for (p.Y = p0.Y - r; p.Y <= p0.Y + r; p.Y++)
- for (p.Z = p0.Z - r; p.Z <= p0.Z + r; p.Z++) {
- // limit to a sphere
- if (p.getDistanceFromSQ(p0) <= r2) {
- // Set in list
- list.insert(p);
- }
- }
+ for(p.X=p0.X-r; p.X<=p0.X+r; p.X++)
+ for(p.Y=p0.Y-r; p.Y<=p0.Y+r; p.Y++)
+ for(p.Z=p0.Z-r; p.Z<=p0.Z+r; p.Z++)
+ {
+ // limit to a sphere
+ if (p.getDistanceFrom(p0) <= r) {
+ // Set in list
+ list.insert(p);
+ }
+ }
}
void fillViewConeBlock(v3s16 p0,
/*
Update m_list
*/
- m_list = newlist;
+ m_list.clear();
+ for (v3s16 p : newlist) {
+ m_list.insert(p);
+ }
}
/*
// If the player exists, ensure that they respawn inside legal bounds
// This fixes an assert crash when the player can't be added
// to the environment
- ServerMap &map = getServerMap();
- if (map.getMapgenParams()->saoPosOverLimit(playersao->getBasePosition())) {
+ if (objectpos_over_limit(playersao->getBasePosition())) {
actionstream << "Respawn position for player \""
<< player->getName() << "\" outside limits, resetting" << std::endl;
playersao->setBasePosition(m_server->findSpawnPos());
{
if(dtime_s < 0.001)
return;
- INodeDefManager *ndef = env->getGameDef()->ndef();
+ const NodeDefManager *ndef = env->getGameDef()->ndef();
for (ABMWithState &abmws : abms) {
ActiveBlockModifier *abm = abmws.abm;
float trigger_interval = abm->getTriggerInterval();
bool ServerEnvironment::setNode(v3s16 p, const MapNode &n)
{
- INodeDefManager *ndef = m_server->ndef();
+ const NodeDefManager *ndef = m_server->ndef();
MapNode n_old = m_map->getNodeNoEx(p);
+ const ContentFeatures &cf_old = ndef->get(n_old);
+
// Call destructor
- if (ndef->get(n_old).has_on_destruct)
+ if (cf_old.has_on_destruct)
m_script->node_on_destruct(p, n_old);
// Replace node
m_map->updateVManip(p);
// Call post-destructor
- if (ndef->get(n_old).has_after_destruct)
+ if (cf_old.has_after_destruct)
m_script->node_after_destruct(p, n_old);
+ // Retrieve node content features
+ // if new node is same as old, reuse old definition to prevent a lookup
+ const ContentFeatures &cf_new = n_old == n ? cf_old : ndef->get(n);
+
// Call constructor
- if (ndef->get(n).has_on_construct)
+ if (cf_new.has_on_construct)
m_script->node_on_construct(p, n);
return true;
bool ServerEnvironment::removeNode(v3s16 p)
{
- INodeDefManager *ndef = m_server->ndef();
+ const NodeDefManager *ndef = m_server->ndef();
MapNode n_old = m_map->getNodeNoEx(p);
// Call destructor
}
}
- // placeholder for the "real" time passed
- float elapsed_time;
-
/*
Mess around in active blocks
*/
- if (m_active_blocks_nodemetadata_interval.step(dtime, m_cache_nodetimer_interval,
- &elapsed_time)) {
+ if (m_active_blocks_nodemetadata_interval.step(dtime, m_cache_nodetimer_interval)) {
ScopeProfiler sp(g_profiler, "SEnv: mess in act. blocks avg per interval", SPT_AVG);
+ float dtime = m_cache_nodetimer_interval;
+
for (const v3s16 &p: m_active_blocks.m_list) {
MapBlock *block = m_map->getBlockNoCreateNoEx(p);
if (!block)
MOD_REASON_BLOCK_EXPIRED);
// Run node timers
- std::vector<NodeTimer> elapsed_timers = block->m_node_timers.step(elapsed_time);
+ std::vector<NodeTimer> elapsed_timers = block->m_node_timers.step(dtime);
if (!elapsed_timers.empty()) {
MapNode n;
v3s16 p2;
}
}
- if (m_active_block_modifier_interval.step(dtime,
- m_cache_abm_interval * m_active_block_interval_overload_skip, &elapsed_time))
+ if (m_active_block_modifier_interval.step(dtime, m_cache_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 per interval", SPT_AVG);
TimeTaker timer("modify in active blocks per interval");
// Initialize handling of ActiveBlockModifiers
- ABMHandler abmhandler(m_abms, elapsed_time, this, true);
+ ABMHandler abmhandler(m_abms, m_cache_abm_interval, this, true);
for (const v3s16 &p : m_active_blocks.m_abm_list) {
MapBlock *block = m_map->getBlockNoCreateNoEx(p);
abmhandler.apply(block);
}
- const u32 time_ms = timer.stop(true);
- // allow up to 10% of the budget interval
- const u32 max_time_ms = m_cache_abm_interval * 1000.0f * 0.1f;
+ u32 time_ms = timer.stop(true);
+ u32 max_time_ms = 200;
if (time_ms > max_time_ms) {
- warningstream << "active block modifiers took "
- << time_ms << "ms (longer than "
- << max_time_ms << "ms)" << std::endl;
- m_active_block_interval_overload_skip = ((float)time_ms / max_time_ms);
- } else {
- m_active_block_interval_overload_skip = 1.0f;
+ warningstream<<"active block modifiers took "
+ <<time_ms<<"ms (longer than "
+ <<max_time_ms<<"ms)"<<std::endl;
+ m_active_block_interval_overload_skip = (time_ms / max_time_ms) + 1;
}
}while(0);
/*
Step active objects
*/
- if (m_active_object_interval.step(dtime,
- m_cache_ao_interval * m_active_object_interval_overload_skip, &elapsed_time)) {
-
+ {
ScopeProfiler sp(g_profiler, "SEnv: step act. objs avg", SPT_AVG);
- TimeTaker timer("Step active objects");
+ //TimeTaker timer("Step active objects");
g_profiler->avg("SEnv: num of objects", m_active_objects.size());
// This helps the objects to send data at the same time
bool send_recommended = false;
- m_send_recommended_timer += elapsed_time;
+ m_send_recommended_timer += dtime;
if(m_send_recommended_timer > getSendRecommendedInterval())
{
m_send_recommended_timer -= getSendRecommendedInterval();
continue;
// Step object
- obj->step(elapsed_time, send_recommended);
+ obj->step(dtime, send_recommended);
// Read messages from object
while (!obj->m_messages_out.empty()) {
m_active_object_messages.push(obj->m_messages_out.front());
obj->m_messages_out.pop();
}
}
-
- // calculate a simple moving average
- m_avg_ao_time = m_avg_ao_time * 0.9f + timer.stop(true) * 0.1f;
-
- // allow up to 20% of the budget interval
- const float max_time_ms = m_cache_ao_interval * 1000.0f * 0.2f;
- if (m_avg_ao_time > max_time_ms) {
- warningstream << "active objects took "
- << m_avg_ao_time << "ms (longer than "
- << max_time_ms << "ms)" << std::endl;
- // skip a few steps
- m_active_object_interval_overload_skip = m_avg_ao_time / max_time_ms;
- } else {
- m_active_object_interval_overload_skip = 1.0f;
- }
}
/*
projects / minetest.git / blobdiff