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