src/environment.cpp

   1 /*
   2 Minetest-c55
   3 Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 2 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License along
  16 with this program; if not, write to the Free Software Foundation, Inc.,
  17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #include "environment.h"
  21 #include "filesys.h"
  22 #include "porting.h"
  23
  24 Environment::Environment()
  25 {
  26         m_daynight_ratio = 0.5;
  27 }
  28
  29 Environment::~Environment()
  30 {
  31         // Deallocate players
  32         for(core::list<Player*>::Iterator i = m_players.begin();
  33                         i != m_players.end(); i++)
  34         {
  35                 delete (*i);
  36         }
  37 }
  38
  39 void Environment::addPlayer(Player *player)
  40 {
  41         DSTACK(__FUNCTION_NAME);
  42         /*
  43                 Check that peer_ids are unique.
  44                 Also check that names are unique.
  45                 Exception: there can be multiple players with peer_id=0
  46         */
  47         // If peer id is non-zero, it has to be unique.
  48         if(player->peer_id != 0)
  49                 assert(getPlayer(player->peer_id) == NULL);
  50         // Name has to be unique.
  51         assert(getPlayer(player->getName()) == NULL);
  52         // Add.
  53         m_players.push_back(player);
  54 }
  55
  56 void Environment::removePlayer(u16 peer_id)
  57 {
  58         DSTACK(__FUNCTION_NAME);
  59 re_search:
  60         for(core::list<Player*>::Iterator i = m_players.begin();
  61                         i != m_players.end(); i++)
  62         {
  63                 Player *player = *i;
  64                 if(player->peer_id != peer_id)
  65                         continue;
  66
  67                 delete player;
  68                 m_players.erase(i);
  69                 // See if there is an another one
  70                 // (shouldn't be, but just to be sure)
  71                 goto re_search;
  72         }
  73 }
  74
  75 Player * Environment::getPlayer(u16 peer_id)
  76 {
  77         for(core::list<Player*>::Iterator i = m_players.begin();
  78                         i != m_players.end(); i++)
  79         {
  80                 Player *player = *i;
  81                 if(player->peer_id == peer_id)
  82                         return player;
  83         }
  84         return NULL;
  85 }
  86
  87 Player * Environment::getPlayer(const char *name)
  88 {
  89         for(core::list<Player*>::Iterator i = m_players.begin();
  90                         i != m_players.end(); i++)
  91         {
  92                 Player *player = *i;
  93                 if(strcmp(player->getName(), name) == 0)
  94                         return player;
  95         }
  96         return NULL;
  97 }
  98
  99 core::list<Player*> Environment::getPlayers()
 100 {
 101         return m_players;
 102 }
 103
 104 core::list<Player*> Environment::getPlayers(bool ignore_disconnected)
 105 {
 106         core::list<Player*> newlist;
 107         for(core::list<Player*>::Iterator
 108                         i = m_players.begin();
 109                         i != m_players.end(); i++)
 110         {
 111                 Player *player = *i;
 112
 113                 if(ignore_disconnected)
 114                 {
 115                         // Ignore disconnected players
 116                         if(player->peer_id == 0)
 117                                 continue;
 118                 }
 119
 120                 newlist.push_back(player);
 121         }
 122         return newlist;
 123 }
 124
 125 void Environment::printPlayers(std::ostream &o)
 126 {
 127         o<<"Players in environment:"<<std::endl;
 128         for(core::list<Player*>::Iterator i = m_players.begin();
 129                         i != m_players.end(); i++)
 130         {
 131                 Player *player = *i;
 132                 o<<"Player peer_id="<<player->peer_id<<std::endl;
 133         }
 134 }
 135
 136 void Environment::setDayNightRatio(u32 r)
 137 {
 138         m_daynight_ratio = r;
 139 }
 140
 141 u32 Environment::getDayNightRatio()
 142 {
 143         return m_daynight_ratio;
 144 }
 145
 146 /*
 147         ServerEnvironment
 148 */
 149
 150 ServerEnvironment::ServerEnvironment(ServerMap *map):
 151         m_map(map),
 152         m_random_spawn_timer(0)
 153 {
 154 }
 155
 156 ServerEnvironment::~ServerEnvironment()
 157 {
 158         // Drop/delete map
 159         m_map->drop();
 160 }
 161
 162 void ServerEnvironment::serializePlayers(const std::string &savedir)
 163 {
 164         std::string players_path = savedir + "/players";
 165         fs::CreateDir(players_path);
 166
 167         core::map<Player*, bool> saved_players;
 168
 169         std::vector<fs::DirListNode> player_files = fs::GetDirListing(players_path);
 170         for(u32 i=0; i<player_files.size(); i++)
 171         {
 172                 if(player_files[i].dir)
 173                         continue;
 174
 175                 // Full path to this file
 176                 std::string path = players_path + "/" + player_files[i].name;
 177
 178                 //dstream<<"Checking player file "<<path<<std::endl;
 179
 180                 // Load player to see what is its name
 181                 ServerRemotePlayer testplayer;
 182                 {
 183                         // Open file and deserialize
 184                         std::ifstream is(path.c_str(), std::ios_base::binary);
 185                         if(is.good() == false)
 186                         {
 187                                 dstream<<"Failed to read "<<path<<std::endl;
 188                                 continue;
 189                         }
 190                         testplayer.deSerialize(is);
 191                 }
 192
 193                 //dstream<<"Loaded test player with name "<<testplayer.getName()<<std::endl;
 194
 195                 // Search for the player
 196                 std::string playername = testplayer.getName();
 197                 Player *player = getPlayer(playername.c_str());
 198                 if(player == NULL)
 199                 {
 200                         dstream<<"Didn't find matching player, ignoring file "<<path<<std::endl;
 201                         continue;
 202                 }
 203
 204                 //dstream<<"Found matching player, overwriting."<<std::endl;
 205
 206                 // OK, found. Save player there.
 207                 {
 208                         // Open file and serialize
 209                         std::ofstream os(path.c_str(), std::ios_base::binary);
 210                         if(os.good() == false)
 211                         {
 212                                 dstream<<"Failed to overwrite "<<path<<std::endl;
 213                                 continue;
 214                         }
 215                         player->serialize(os);
 216                         saved_players.insert(player, true);
 217                 }
 218         }
 219
 220         for(core::list<Player*>::Iterator i = m_players.begin();
 221                         i != m_players.end(); i++)
 222         {
 223                 Player *player = *i;
 224                 if(saved_players.find(player) != NULL)
 225                 {
 226                         /*dstream<<"Player "<<player->getName()
 227                                         <<" was already saved."<<std::endl;*/
 228                         continue;
 229                 }
 230                 std::string playername = player->getName();
 231                 // Don't save unnamed player
 232                 if(playername == "")
 233                 {
 234                         //dstream<<"Not saving unnamed player."<<std::endl;
 235                         continue;
 236                 }
 237                 /*
 238                         Find a sane filename
 239                 */
 240                 if(string_allowed(playername, PLAYERNAME_ALLOWED_CHARS) == false)
 241                         playername = "player";
 242                 std::string path = players_path + "/" + playername;
 243                 bool found = false;
 244                 for(u32 i=0; i<1000; i++)
 245                 {
 246                         if(fs::PathExists(path) == false)
 247                         {
 248                                 found = true;
 249                                 break;
 250                         }
 251                         path = players_path + "/" + playername + itos(i);
 252                 }
 253                 if(found == false)
 254                 {
 255                         dstream<<"WARNING: Didn't find free file for player"<<std::endl;
 256                         continue;
 257                 }
 258
 259                 {
 260                         /*dstream<<"Saving player "<<player->getName()<<" to "
 261                                         <<path<<std::endl;*/
 262                         // Open file and serialize
 263                         std::ofstream os(path.c_str(), std::ios_base::binary);
 264                         if(os.good() == false)
 265                         {
 266                                 dstream<<"WARNING: Failed to overwrite "<<path<<std::endl;
 267                                 continue;
 268                         }
 269                         player->serialize(os);
 270                         saved_players.insert(player, true);
 271                 }
 272         }
 273
 274         //dstream<<"Saved "<<saved_players.size()<<" players."<<std::endl;
 275 }
 276
 277 void ServerEnvironment::deSerializePlayers(const std::string &savedir)
 278 {
 279         std::string players_path = savedir + "/players";
 280
 281         core::map<Player*, bool> saved_players;
 282
 283         std::vector<fs::DirListNode> player_files = fs::GetDirListing(players_path);
 284         for(u32 i=0; i<player_files.size(); i++)
 285         {
 286                 if(player_files[i].dir)
 287                         continue;
 288
 289                 // Full path to this file
 290                 std::string path = players_path + "/" + player_files[i].name;
 291
 292                 dstream<<"Checking player file "<<path<<std::endl;
 293
 294                 // Load player to see what is its name
 295                 ServerRemotePlayer testplayer;
 296                 {
 297                         // Open file and deserialize
 298                         std::ifstream is(path.c_str(), std::ios_base::binary);
 299                         if(is.good() == false)
 300                         {
 301                                 dstream<<"Failed to read "<<path<<std::endl;
 302                                 continue;
 303                         }
 304                         testplayer.deSerialize(is);
 305                 }
 306
 307                 dstream<<"Loaded test player with name "<<testplayer.getName()<<std::endl;
 308
 309                 // Search for the player
 310                 std::string playername = testplayer.getName();
 311                 Player *player = getPlayer(playername.c_str());
 312                 bool newplayer = false;
 313                 if(player == NULL)
 314                 {
 315                         dstream<<"Is a new player"<<std::endl;
 316                         player = new ServerRemotePlayer();
 317                         newplayer = true;
 318                 }
 319
 320                 // Load player
 321                 {
 322                         dstream<<"Reading player "<<testplayer.getName()<<" from "
 323                                         <<path<<std::endl;
 324                         // Open file and deserialize
 325                         std::ifstream is(path.c_str(), std::ios_base::binary);
 326                         if(is.good() == false)
 327                         {
 328                                 dstream<<"Failed to read "<<path<<std::endl;
 329                                 continue;
 330                         }
 331                         player->deSerialize(is);
 332                 }
 333
 334                 if(newplayer)
 335                         addPlayer(player);
 336         }
 337 }
 338
 339 void ServerEnvironment::step(float dtime)
 340 {
 341         DSTACK(__FUNCTION_NAME);
 342
 343         // Get some settings
 344         //bool free_move = g_settings.getBool("free_move");
 345         bool footprints = g_settings.getBool("footprints");
 346
 347         {
 348                 //TimeTaker timer("Server m_map->timerUpdate()", g_device);
 349                 m_map->timerUpdate(dtime);
 350         }
 351
 352         /*
 353                 Handle players
 354         */
 355         for(core::list<Player*>::Iterator i = m_players.begin();
 356                         i != m_players.end(); i++)
 357         {
 358                 Player *player = *i;
 359                 v3f playerpos = player->getPosition();
 360
 361                 // Move
 362                 player->move(dtime, *m_map, 100*BS);
 363
 364                 /*
 365                         Add footsteps to grass
 366                 */
 367                 if(footprints)
 368                 {
 369                         // Get node that is at BS/4 under player
 370                         v3s16 bottompos = floatToInt(playerpos + v3f(0,-BS/4,0), BS);
 371                         try{
 372                                 MapNode n = m_map->getNode(bottompos);
 373                                 if(n.d == CONTENT_GRASS)
 374                                 {
 375                                         n.d = CONTENT_GRASS_FOOTSTEPS;
 376                                         m_map->setNode(bottompos, n);
 377                                 }
 378                         }
 379                         catch(InvalidPositionException &e)
 380                         {
 381                         }
 382                 }
 383         }
 384
 385         /*
 386                 Step active objects
 387         */
 388         for(core::map<u16, ServerActiveObject*>::Iterator
 389                         i = m_active_objects.getIterator();
 390                         i.atEnd()==false; i++)
 391         {
 392                 ServerActiveObject* obj = i.getNode()->getValue();
 393                 // Step object, putting messages directly to the queue
 394                 obj->step(dtime, m_active_object_messages);
 395         }
 396
 397         /*
 398                 Remove (m_removed && m_known_by_count==0) objects
 399         */
 400         {
 401                 core::list<u16> objects_to_remove;
 402                 for(core::map<u16, ServerActiveObject*>::Iterator
 403                                 i = m_active_objects.getIterator();
 404                                 i.atEnd()==false; i++)
 405                 {
 406                         u16 id = i.getNode()->getKey();
 407                         ServerActiveObject* obj = i.getNode()->getValue();
 408                         // This shouldn't happen but check it
 409                         if(obj == NULL)
 410                         {
 411                                 dstream<<"WARNING: NULL object found in ServerEnvironment"
 412                                                 <<" while finding removed objects. id="<<id<<std::endl;
 413                                 // Id to be removed from m_active_objects
 414                                 objects_to_remove.push_back(id);
 415                                 continue;
 416                         }
 417                         else
 418                         {
 419                                 // If not m_removed, don't remove.
 420                                 if(obj->m_removed == false)
 421                                         continue;
 422                                 // Delete
 423                                 delete obj;
 424                                 // Id to be removed from m_active_objects
 425                                 objects_to_remove.push_back(id);
 426                         }
 427                 }
 428                 // Remove references from m_active_objects
 429                 for(core::list<u16>::Iterator i = objects_to_remove.begin();
 430                                 i != objects_to_remove.end(); i++)
 431                 {
 432                         m_active_objects.remove(*i);
 433                 }
 434         }
 435
 436         /*
 437                 TEST CODE
 438         */
 439         m_random_spawn_timer -= dtime;
 440         if(m_random_spawn_timer < 0)
 441         {
 442                 m_random_spawn_timer += myrand_range(2.0, 20.0);
 443
 444                 /*TestSAO *obj = new TestSAO(0,
 445                                 v3f(myrand_range(-2*BS,2*BS), BS*5, myrand_range(-2*BS,2*BS)));*/
 446
 447                 /*
 448                         Create a Lua ServerActiveObject somewhere near the origin
 449                 */
 450                 LuaSAO *obj = new LuaSAO(this, 0,
 451                                 v3f(myrand_range(-2*BS,2*BS),
 452                                 myrand_range(2*BS,9*BS),
 453                                 myrand_range(-2*BS,2*BS))
 454                 );
 455
 456                 /*
 457                         Select a random type for it
 458                 */
 459                 std::string objectdir = porting::getDataPath("luaobjects");
 460                 std::vector<fs::DirListNode> dirlist = fs::GetDirListing(objectdir);
 461                 u32 selected_i = myrand_range(0, dirlist.size()-1);
 462                 std::string selected_name = "";
 463                 selected_name = dirlist[selected_i].name;
 464                 /*for(u32 i=0; i<dirlist.size(); i++)*/
 465
 466                 dstream<<"ServerEnvironment: Selected script name \""<<selected_name
 467                                 <<"\" for new lua object"<<std::endl;
 468
 469                 /*
 470                         Load the scripts for the type
 471                 */
 472                 obj->loadScripts(selected_name.c_str());
 473
 474                 // Add the object to the environment
 475                 addActiveObject(obj);
 476         }
 477 }
 478
 479 ServerActiveObject* ServerEnvironment::getActiveObject(u16 id)
 480 {
 481         core::map<u16, ServerActiveObject*>::Node *n;
 482         n = m_active_objects.find(id);
 483         if(n == NULL)
 484                 return NULL;
 485         return n->getValue();
 486 }
 487
 488 bool isFreeServerActiveObjectId(u16 id,
 489                 core::map<u16, ServerActiveObject*> &objects)
 490 {
 491         if(id == 0)
 492                 return false;
 493
 494         for(core::map<u16, ServerActiveObject*>::Iterator
 495                         i = objects.getIterator();
 496                         i.atEnd()==false; i++)
 497         {
 498                 if(i.getNode()->getKey() == id)
 499                         return false;
 500         }
 501         return true;
 502 }
 503
 504 u16 getFreeServerActiveObjectId(
 505                 core::map<u16, ServerActiveObject*> &objects)
 506 {
 507         u16 new_id = 1;
 508         for(;;)
 509         {
 510                 if(isFreeServerActiveObjectId(new_id, objects))
 511                         return new_id;
 512
 513                 if(new_id == 65535)
 514                         return 0;
 515
 516                 new_id++;
 517         }
 518 }
 519
 520 u16 ServerEnvironment::addActiveObject(ServerActiveObject *object)
 521 {
 522         assert(object);
 523         if(object->getId() == 0)
 524         {
 525                 u16 new_id = getFreeServerActiveObjectId(m_active_objects);
 526                 if(new_id == 0)
 527                 {
 528                         dstream<<"WARNING: ServerEnvironment::addActiveObject(): "
 529                                         <<"no free ids available"<<std::endl;
 530                         delete object;
 531                         return 0;
 532                 }
 533                 object->setId(new_id);
 534         }
 535         if(isFreeServerActiveObjectId(object->getId(), m_active_objects) == false)
 536         {
 537                 dstream<<"WARNING: ServerEnvironment::addActiveObject(): "
 538                                 <<"id is not free ("<<object->getId()<<")"<<std::endl;
 539                 delete object;
 540                 return 0;
 541         }
 542         dstream<<"INGO: ServerEnvironment::addActiveObject(): "
 543                         <<"added (id="<<object->getId()<<")"<<std::endl;
 544         m_active_objects.insert(object->getId(), object);
 545         return object->getId();
 546 }
 547
 548 /*
 549         Finds out what new objects have been added to
 550         inside a radius around a position
 551 */
 552 void ServerEnvironment::getAddedActiveObjects(v3s16 pos, s16 radius,
 553                 core::map<u16, bool> &current_objects,
 554                 core::map<u16, bool> &added_objects)
 555 {
 556         v3f pos_f = intToFloat(pos, BS);
 557         f32 radius_f = radius * BS;
 558         /*
 559                 Go through the object list,
 560                 - discard m_removed objects,
 561                 - discard objects that are too far away,
 562                 - discard objects that are found in current_objects.
 563                 - add remaining objects to added_objects
 564         */
 565         for(core::map<u16, ServerActiveObject*>::Iterator
 566                         i = m_active_objects.getIterator();
 567                         i.atEnd()==false; i++)
 568         {
 569                 u16 id = i.getNode()->getKey();
 570                 // Get object
 571                 ServerActiveObject *object = i.getNode()->getValue();
 572                 if(object == NULL)
 573                         continue;
 574                 // Discard if removed
 575                 if(object->m_removed)
 576                         continue;
 577                 // Discard if too far
 578                 f32 distance_f = object->getBasePosition().getDistanceFrom(pos_f);
 579                 if(distance_f > radius_f)
 580                         continue;
 581                 // Discard if already on current_objects
 582                 core::map<u16, bool>::Node *n;
 583                 n = current_objects.find(id);
 584                 if(n != NULL)
 585                         continue;
 586                 // Add to added_objects
 587                 added_objects.insert(id, false);
 588         }
 589 }
 590
 591 /*
 592         Finds out what objects have been removed from
 593         inside a radius around a position
 594 */
 595 void ServerEnvironment::getRemovedActiveObjects(v3s16 pos, s16 radius,
 596                 core::map<u16, bool> &current_objects,
 597                 core::map<u16, bool> &removed_objects)
 598 {
 599         v3f pos_f = intToFloat(pos, BS);
 600         f32 radius_f = radius * BS;
 601         /*
 602                 Go through current_objects; object is removed if:
 603                 - object is not found in m_active_objects (this is actually an
 604                   error condition; objects should be set m_removed=true and removed
 605                   only after all clients have been informed about removal), or
 606                 - object has m_removed=true, or
 607                 - object is too far away
 608         */
 609         for(core::map<u16, bool>::Iterator
 610                         i = current_objects.getIterator();
 611                         i.atEnd()==false; i++)
 612         {
 613                 u16 id = i.getNode()->getKey();
 614                 ServerActiveObject *object = getActiveObject(id);
 615                 if(object == NULL)
 616                 {
 617                         dstream<<"WARNING: ServerEnvironment::getRemovedActiveObjects():"
 618                                         <<" object in current_objects is NULL"<<std::endl;
 619                 }
 620                 else if(object->m_removed == false)
 621                 {
 622                         f32 distance_f = object->getBasePosition().getDistanceFrom(pos_f);
 623                         /*dstream<<"removed == false"
 624                                         <<"distance_f = "<<distance_f
 625                                         <<", radius_f = "<<radius_f<<std::endl;*/
 626                         if(distance_f < radius_f)
 627                         {
 628                                 // Not removed
 629                                 continue;
 630                         }
 631                 }
 632                 removed_objects.insert(id, false);
 633         }
 634 }
 635
 636 ActiveObjectMessage ServerEnvironment::getActiveObjectMessage()
 637 {
 638         if(m_active_object_messages.size() == 0)
 639                 return ActiveObjectMessage(0);
 640
 641         return m_active_object_messages.pop_front();
 642 }
 643
 644 #ifndef SERVER
 645
 646 /*
 647         ClientEnvironment
 648 */
 649
 650 ClientEnvironment::ClientEnvironment(ClientMap *map, scene::ISceneManager *smgr):
 651         m_map(map),
 652         m_smgr(smgr)
 653 {
 654         assert(m_map);
 655         assert(m_smgr);
 656 }
 657
 658 ClientEnvironment::~ClientEnvironment()
 659 {
 660         // delete active objects
 661         for(core::map<u16, ClientActiveObject*>::Iterator
 662                         i = m_active_objects.getIterator();
 663                         i.atEnd()==false; i++)
 664         {
 665                 delete i.getNode()->getValue();
 666         }
 667
 668         // Drop/delete map
 669         m_map->drop();
 670 }
 671
 672 void ClientEnvironment::addPlayer(Player *player)
 673 {
 674         DSTACK(__FUNCTION_NAME);
 675         /*
 676                 It is a failure if player is local and there already is a local
 677                 player
 678         */
 679         assert(!(player->isLocal() == true && getLocalPlayer() != NULL));
 680
 681         Environment::addPlayer(player);
 682 }
 683
 684 LocalPlayer * ClientEnvironment::getLocalPlayer()
 685 {
 686         for(core::list<Player*>::Iterator i = m_players.begin();
 687                         i != m_players.end(); i++)
 688         {
 689                 Player *player = *i;
 690                 if(player->isLocal())
 691                         return (LocalPlayer*)player;
 692         }
 693         return NULL;
 694 }
 695
 696 void ClientEnvironment::step(float dtime)
 697 {
 698         DSTACK(__FUNCTION_NAME);
 699
 700         // Get some settings
 701         bool free_move = g_settings.getBool("free_move");
 702         bool footprints = g_settings.getBool("footprints");
 703
 704         {
 705                 //TimeTaker timer("Client m_map->timerUpdate()", g_device);
 706                 m_map->timerUpdate(dtime);
 707         }
 708
 709         /*
 710                 Get the speed the player is going
 711         */
 712         f32 player_speed = 0.001; // just some small value
 713         LocalPlayer *lplayer = getLocalPlayer();
 714         if(lplayer)
 715                 player_speed = lplayer->getSpeed().getLength();
 716
 717         /*
 718                 Maximum position increment
 719         */
 720         //f32 position_max_increment = 0.05*BS;
 721         f32 position_max_increment = 0.1*BS;
 722
 723         // Maximum time increment (for collision detection etc)
 724         // time = distance / speed
 725         f32 dtime_max_increment = position_max_increment / player_speed;
 726
 727         // Maximum time increment is 10ms or lower
 728         if(dtime_max_increment > 0.01)
 729                 dtime_max_increment = 0.01;
 730
 731         // Don't allow overly huge dtime
 732         if(dtime > 0.5)
 733                 dtime = 0.5;
 734
 735         f32 dtime_downcount = dtime;
 736
 737         /*
 738                 Stuff that has a maximum time increment
 739         */
 740
 741         u32 loopcount = 0;
 742         do
 743         {
 744                 loopcount++;
 745
 746                 f32 dtime_part;
 747                 if(dtime_downcount > dtime_max_increment)
 748                         dtime_part = dtime_max_increment;
 749                 else
 750                         dtime_part = dtime_downcount;
 751                 dtime_downcount -= dtime_part;
 752
 753                 /*
 754                         Handle local player
 755                 */
 756
 757                 {
 758                         Player *player = getLocalPlayer();
 759
 760                         v3f playerpos = player->getPosition();
 761
 762                         // Apply physics
 763                         if(free_move == false)
 764                         {
 765                                 // Gravity
 766                                 v3f speed = player->getSpeed();
 767                                 if(player->swimming_up == false)
 768                                         speed.Y -= 9.81 * BS * dtime_part * 2;
 769
 770                                 // Water resistance
 771                                 if(player->in_water_stable || player->in_water)
 772                                 {
 773                                         f32 max_down = 2.0*BS;
 774                                         if(speed.Y < -max_down) speed.Y = -max_down;
 775
 776                                         f32 max = 2.5*BS;
 777                                         if(speed.getLength() > max)
 778                                         {
 779                                                 speed = speed / speed.getLength() * max;
 780                                         }
 781                                 }
 782
 783                                 player->setSpeed(speed);
 784                         }
 785
 786                         /*
 787                                 Move the player.
 788                                 This also does collision detection.
 789                         */
 790                         player->move(dtime_part, *m_map, position_max_increment);
 791                 }
 792         }
 793         while(dtime_downcount > 0.001);
 794
 795         //std::cout<<"Looped "<<loopcount<<" times."<<std::endl;
 796
 797         /*
 798                 Stuff that can be done in an arbitarily large dtime
 799         */
 800         for(core::list<Player*>::Iterator i = m_players.begin();
 801                         i != m_players.end(); i++)
 802         {
 803                 Player *player = *i;
 804                 v3f playerpos = player->getPosition();
 805
 806                 /*
 807                         Handle non-local players
 808                 */
 809                 if(player->isLocal() == false)
 810                 {
 811                         // Move
 812                         player->move(dtime, *m_map, 100*BS);
 813
 814                         // Update lighting on remote players on client
 815                         u8 light = LIGHT_MAX;
 816                         try{
 817                                 // Get node at head
 818                                 v3s16 p = floatToInt(playerpos + v3f(0,BS+BS/2,0), BS);
 819                                 MapNode n = m_map->getNode(p);
 820                                 light = n.getLightBlend(m_daynight_ratio);
 821                         }
 822                         catch(InvalidPositionException &e) {}
 823                         player->updateLight(light);
 824                 }
 825
 826                 /*
 827                         Add footsteps to grass
 828                 */
 829                 if(footprints)
 830                 {
 831                         // Get node that is at BS/4 under player
 832                         v3s16 bottompos = floatToInt(playerpos + v3f(0,-BS/4,0), BS);
 833                         try{
 834                                 MapNode n = m_map->getNode(bottompos);
 835                                 if(n.d == CONTENT_GRASS)
 836                                 {
 837                                         n.d = CONTENT_GRASS_FOOTSTEPS;
 838                                         m_map->setNode(bottompos, n);
 839                                         // Update mesh on client
 840                                         if(m_map->mapType() == MAPTYPE_CLIENT)
 841                                         {
 842                                                 v3s16 p_blocks = getNodeBlockPos(bottompos);
 843                                                 MapBlock *b = m_map->getBlockNoCreate(p_blocks);
 844                                                 b->updateMesh(m_daynight_ratio);
 845                                         }
 846                                 }
 847                         }
 848                         catch(InvalidPositionException &e)
 849                         {
 850                         }
 851                 }
 852         }
 853
 854         /*
 855                 Step active objects
 856         */
 857         for(core::map<u16, ClientActiveObject*>::Iterator
 858                         i = m_active_objects.getIterator();
 859                         i.atEnd()==false; i++)
 860         {
 861                 ClientActiveObject* obj = i.getNode()->getValue();
 862                 // Step object
 863                 obj->step(dtime);
 864         }
 865 }
 866
 867 void ClientEnvironment::updateMeshes(v3s16 blockpos)
 868 {
 869         m_map->updateMeshes(blockpos, m_daynight_ratio);
 870 }
 871
 872 void ClientEnvironment::expireMeshes(bool only_daynight_diffed)
 873 {
 874         m_map->expireMeshes(only_daynight_diffed);
 875 }
 876
 877 ClientActiveObject* ClientEnvironment::getActiveObject(u16 id)
 878 {
 879         core::map<u16, ClientActiveObject*>::Node *n;
 880         n = m_active_objects.find(id);
 881         if(n == NULL)
 882                 return NULL;
 883         return n->getValue();
 884 }
 885
 886 bool isFreeClientActiveObjectId(u16 id,
 887                 core::map<u16, ClientActiveObject*> &objects)
 888 {
 889         if(id == 0)
 890                 return false;
 891
 892         for(core::map<u16, ClientActiveObject*>::Iterator
 893                         i = objects.getIterator();
 894                         i.atEnd()==false; i++)
 895         {
 896                 if(i.getNode()->getKey() == id)
 897                         return false;
 898         }
 899         return true;
 900 }
 901
 902 u16 getFreeClientActiveObjectId(
 903                 core::map<u16, ClientActiveObject*> &objects)
 904 {
 905         u16 new_id = 1;
 906         for(;;)
 907         {
 908                 if(isFreeClientActiveObjectId(new_id, objects))
 909                         return new_id;
 910
 911                 if(new_id == 65535)
 912                         return 0;
 913
 914                 new_id++;
 915         }
 916 }
 917
 918 u16 ClientEnvironment::addActiveObject(ClientActiveObject *object)
 919 {
 920         assert(object);
 921         if(object->getId() == 0)
 922         {
 923                 u16 new_id = getFreeClientActiveObjectId(m_active_objects);
 924                 if(new_id == 0)
 925                 {
 926                         dstream<<"WARNING: ClientEnvironment::addActiveObject(): "
 927                                         <<"no free ids available"<<std::endl;
 928                         delete object;
 929                         return 0;
 930                 }
 931                 object->setId(new_id);
 932         }
 933         if(isFreeClientActiveObjectId(object->getId(), m_active_objects) == false)
 934         {
 935                 dstream<<"WARNING: ClientEnvironment::addActiveObject(): "
 936                                 <<"id is not free ("<<object->getId()<<")"<<std::endl;
 937                 delete object;
 938                 return 0;
 939         }
 940         dstream<<"INGO: ClientEnvironment::addActiveObject(): "
 941                         <<"added (id="<<object->getId()<<")"<<std::endl;
 942         m_active_objects.insert(object->getId(), object);
 943         object->addToScene(m_smgr);
 944         return object->getId();
 945 }
 946
 947 void ClientEnvironment::addActiveObject(u16 id, u8 type,
 948                 const std::string &init_data)
 949 {
 950         ClientActiveObject* obj = ClientActiveObject::create(type);
 951         if(obj == NULL)
 952         {
 953                 dstream<<"WARNING: ClientEnvironment::addActiveObject(): "
 954                                 <<"id="<<id<<" type="<<type<<": Couldn't create object"
 955                                 <<std::endl;
 956                 return;
 957         }
 958
 959         obj->setId(id);
 960
 961         addActiveObject(obj);
 962
 963         obj->initialize(init_data);
 964 }
 965
 966 void ClientEnvironment::removeActiveObject(u16 id)
 967 {
 968         dstream<<"ClientEnvironment::removeActiveObject(): "
 969                         <<"id="<<id<<std::endl;
 970         ClientActiveObject* obj = getActiveObject(id);
 971         if(obj == NULL)
 972         {
 973                 dstream<<"WARNING: ClientEnvironment::removeActiveObject(): "
 974                                 <<"id="<<id<<" not found"<<std::endl;
 975                 return;
 976         }
 977         obj->removeFromScene();
 978         delete obj;
 979         m_active_objects.remove(id);
 980 }
 981
 982 void ClientEnvironment::processActiveObjectMessage(u16 id,
 983                 const std::string &data)
 984 {
 985         ClientActiveObject* obj = getActiveObject(id);
 986         if(obj == NULL)
 987         {
 988                 dstream<<"WARNING: ClientEnvironment::processActiveObjectMessage():"
 989                                 <<" got message for id="<<id<<", which doesn't exist."
 990                                 <<std::endl;
 991                 return;
 992         }
 993         obj->processMessage(data);
 994 }
 995
 996 #endif // #ifndef SERVER
 997
 998