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