i = m_players.begin();

i != m_players.end(); ++i) {

Player *player = *i;

if(ignore_disconnected) {

// Ignore disconnected players

if(player->peer_id == 0)

{

// getTimeOfDaySpeed lock the value we need to prevent MT problems

float day_speed = getTimeOfDaySpeed();

m_time_counter += dtime;

f32 speed = day_speed * 24000./(24.*3600);

u32 units = (u32)(m_time_counter*speed);

Player *ServerEnvironment::loadPlayer(const std::string &playername)

{

bool newplayer = false;

bool found = false;

if (!player) {

newplayer = true;

}

for (u32 i = 0; i < PLAYER_FILE_ALTERNATE_TRIES; i++) {

std::ifstream is(path.c_str(), std::ios_base::binary);

is.close();

found = true;

break;

}

path = players_path + playername + itos(i);

}

if (!found) {

infostream << "Player file for player " << playername

<< " not found" << std::endl;

return NULL;

}

addPlayer(player);

player->setModified(false);

return player;

}

/*infostream<<"ServerEnvironment::activateBlock(): block is "

// Activate stored objects

activateObjects(block, dtime_s);

void ServerEnvironment::step(float dtime)

{

DSTACK(__FUNCTION_NAME);

//TimeTaker timer("ServerEnv step");

/* Step time of day */

m_game_time += inc_i;

m_game_time_fraction_counter -= (float)inc_i;

}

/*

i != m_players.end(); ++i)

{

Player *player = *i;

// Ignore disconnected players

if(player->peer_id == 0)

continue;

// Move

player->move(dtime, this, 100*BS);

}

floatToInt(player->getPosition(), BS));

players_blockpos.push_back(blockpos);

}

/*

// Convert active objects that are no more in active blocks to static

deactivateFarObjects(false);

for(std::set<v3s16>::iterator

i = blocks_removed.begin();

i != blocks_removed.end(); ++i)

/* infostream<<"Server: Block " << PP(p)

MapBlock *block = m_map->getBlockNoCreateNoEx(p);

if(block==NULL)

continue;

// Set current time as timestamp (and let it set ChangedFlag)

block->setTimestamp(m_game_time);

}

if(m_active_blocks_nodemetadata_interval.step(dtime, 1.0))

{

ScopeProfiler sp(g_profiler, "SEnv: mess in act. blocks avg /1s", SPT_AVG);

float dtime = 1.0;

for(std::set<v3s16>::iterator

i = m_active_blocks.m_list.begin();

i != m_active_blocks.m_list.end(); ++i)

{

v3s16 p = *i;

/*infostream<<"Server: Block ("<<p.X<<","<<p.Y<<","<<p.Z

// Reset block usage timer

block->resetUsageTimer();

// Set current time as timestamp

block->setTimestampNoChangedFlag(m_game_time);

// If time has changed much from the one on disk,

}

}

}

const float abm_interval = 1.0;

if(m_active_block_modifier_interval.step(dtime, abm_interval))

do{ // breakable

}

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);

i != m_active_blocks.m_list.end(); ++i)

{

v3s16 p = *i;

/*infostream<<"Server: Block ("<<p.X<<","<<p.Y<<","<<p.Z

MapBlock *block = m_map->getBlockNoCreateNoEx(p);

if(block == NULL)

continue;

// Set current time as timestamp

block->setTimestampNoChangedFlag(m_game_time);

m_active_block_interval_overload_skip = (time_ms / max_time_ms) + 1;

}

}while(0);

/*

//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 += dtime;

}

}

}

/*

last_used_id ++;

if(isFreeServerActiveObjectId(last_used_id, objects))

return last_used_id;

if(last_used_id == startid)

return 0;

}

removed_objects.insert(id);

continue;

}

f32 distance_f = object->getBasePosition().getDistanceFrom(pos_f);

if (object->getType() == ACTIVEOBJECT_TYPE_PLAYER) {

if (distance_f <= player_radius_f || player_radius_f == 0)

{

if(m_active_object_messages.empty())

return ActiveObjectMessage(0);

ActiveObjectMessage message = m_active_object_messages.front();

m_active_object_messages.pop_front();

return message;

}

/*infostream<<"ServerEnvironment::addActiveObjectRaw(): "

m_active_objects[object->getId()] = object;

verbosestream<<"ServerEnvironment::addActiveObjectRaw(): "

<<"Added id="<<object->getId()<<"; there are now "

<<m_active_objects.size()<<" active objects."

<<std::endl;

// Register reference in scripting api (must be done before post-init)

m_script->addObjectReference(object);

// Post-initialize object

object->addedToEnvironment(dtime_s);

// Add static data to block

if(object->isStaticAllowed())

{

<<" statically (pos="<<PP(p)<<")"<<std::endl;

}

}

return object->getId();

}

<<"in block "<<PP(s_obj.pos/BS)

<<" type="<<(int)s_obj.type<<" data:"<<std::endl;

print_hexdump(verbosestream, s_obj.data);

new_stored.push_back(s_obj);

continue;

}

i != m_active_objects.end(); ++i) {

ServerActiveObject* obj = i->second;

assert(obj);

// Do not deactivate if static data creation not allowed

if(!force_delete && !obj->isStaticAllowed())

continue;

// Create new static object

std::string staticdata_new = obj->getStaticData();

StaticObject s_obj(obj->getType(), objectpos, staticdata_new);

bool stays_in_same_block = false;

bool data_changed = true;

stays_in_same_block = true;

MapBlock *block = m_map->emergeBlock(obj->m_static_block, false);

std::map<u16, StaticObject>::iterator n =

block->m_static_objects.m_active.find(id);

if(n != block->m_static_objects.m_active.end()){

}

bool shall_be_written = (!stays_in_same_block || data_changed);

// Delete old static object

if(obj->m_static_exists)

{

// 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)

block->raiseModified(MOD_STATE_WRITE_NEEDED,

"deactivateFarObjects: Static data "

"changed considerably");

obj->m_static_exists = true;

obj->m_static_block = block->getPos();

}

obj->m_pending_deactivation = true;

continue;

}

verbosestream<<"ServerEnvironment::deactivateFarObjects(): "

<<"object id="<<id<<" is not known by clients"

<<"; deleting"<<std::endl;

assert(lplayer);

// collision info queue

std::vector<CollisionInfo> player_collisions;

/*

bool is_climbing = lplayer->is_climbing;

f32 player_speed = lplayer->getSpeed().getLength();

/*

f32 dtime_max_increment = 1;

if(player_speed > 0.001)

dtime_max_increment = position_max_increment / player_speed;

// Maximum time increment is 10ms or lower

if(dtime_max_increment > 0.01)

dtime_max_increment = 0.01;

// Don't allow overly huge dtime

if(dtime > 0.5)

dtime = 0.5;

f32 dtime_downcount = dtime;

/*

dtime_downcount = 0;

}

/*

{

// Apply physics

if(free_move == false && is_climbing == false)

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;

}

}

while(dtime_downcount > 0.001);

//std::cout<<"Looped "<<loopcount<<" times."<<std::endl;

for(std::vector<CollisionInfo>::iterator i = player_collisions.begin();

i != player_collisions.end(); ++i) {

CollisionInfo &info = *i;

}

}

}

/*

if(m_lava_hurt_interval.step(dtime, 1.0))

{

v3f pf = lplayer->getPosition();

// Feet, middle and head

v3s16 p1 = floatToInt(pf + v3f(0, BS*0.1, 0), BS);

MapNode n1 = m_map->getNodeNoEx(p1);

m_gamedef->ndef()->get(n2).damage_per_second);

damage_per_second = MYMAX(damage_per_second,

m_gamedef->ndef()->get(n3).damage_per_second);

if(damage_per_second != 0)

{

damageLocalPlayer(damage_per_second, true);

for(std::vector<Player*>::iterator i = m_players.begin();

i != m_players.end(); ++i) {

Player *player = *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<u16, ClientActiveObject*>::iterator

}

}

}

void ClientEnvironment::addSimpleObject(ClientSimpleObject *simple)

{

m_simple_objects.push_back(simple);

last_used_id ++;

if(isFreeClientActiveObjectId(last_used_id, objects))

return last_used_id;

if(last_used_id == startid)

return 0;

}

<<std::endl;

return;

}

obj->setId(id);

try

void ClientEnvironment::getActiveObjects(v3f origin, f32 max_d,

std::vector<DistanceSortedActiveObject> &dest)

{

struct HudElement;

class Environment;

class Player

{

virtual void move(f32 dtime, Environment *env, f32 pos_max_d)

{}

virtual void move(f32 dtime, Environment *env, f32 pos_max_d,

{}

v3f getSpeed()

{

m_speed = speed;

}

void accelerateHorizontal(v3f target_speed, f32 max_increase);

void accelerateVertical(v3f target_speed, f32 max_increase);

bool is_climbing;

bool swimming_vertical;

bool camera_barely_in_ceiling;

Inventory inventory;

f32 movement_acceleration_default;

u16 peer_id;

std::string inventory_formspec;

PlayerControl control;

PlayerControl getPlayerControl()

{

return control;

}

u32 keyPressed;

HudElement* getHud(u32 id);

u32 addHud(HudElement* hud);

void setPlayerSAO(PlayerSAO *sao)

{ m_sao = sao; }

void setPosition(const v3f &position);

PlayerSAO *m_sao;

};