src/client.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 "client.h"
  21 #include "utility.h"
  22 #include <iostream>
  23 #include "clientserver.h"
  24 #include "jmutexautolock.h"
  25 #include "main.h"
  26 #include <sstream>
  27 #include "porting.h"
  28
  29 void * ClientUpdateThread::Thread()
  30 {
  31         ThreadStarted();
  32
  33         DSTACK(__FUNCTION_NAME);
  34
  35 #if CATCH_UNHANDLED_EXCEPTIONS
  36         try
  37         {
  38 #endif
  39                 while(getRun())
  40                 {
  41                         m_client->asyncStep();
  42
  43                         //m_client->updateSomeExpiredMeshes();
  44
  45                         bool was = m_client->AsyncProcessData();
  46
  47                         if(was == false)
  48                                 sleep_ms(10);
  49                 }
  50 #if CATCH_UNHANDLED_EXCEPTIONS
  51         }
  52         /*
  53                 This is what has to be done in threads to get suitable debug info
  54         */
  55         catch(std::exception &e)
  56         {
  57                 dstream<<std::endl<<DTIME<<"An unhandled exception occurred: "
  58                                 <<e.what()<<std::endl;
  59                 assert(0);
  60         }
  61 #endif
  62
  63         return NULL;
  64 }
  65
  66 Client::Client(
  67                 IrrlichtDevice *device,
  68                 const char *playername,
  69                 JMutex &range_mutex,
  70                 s16 &viewing_range_nodes,
  71                 bool &viewing_range_all):
  72         m_thread(this),
  73         m_env(new ClientMap(this,
  74                         range_mutex,
  75                         viewing_range_nodes,
  76                         viewing_range_all,
  77                         device->getSceneManager()->getRootSceneNode(),
  78                         device->getSceneManager(), 666),
  79                         dout_client),
  80         m_con(PROTOCOL_ID, 512, CONNECTION_TIMEOUT, this),
  81         m_device(device),
  82         camera_position(0,0,0),
  83         camera_direction(0,0,1),
  84         m_server_ser_ver(SER_FMT_VER_INVALID),
  85         m_step_dtime(0.0),
  86         m_inventory_updated(false),
  87         m_time_of_day(0)
  88 {
  89         m_packetcounter_timer = 0.0;
  90         m_delete_unused_sectors_timer = 0.0;
  91         m_connection_reinit_timer = 0.0;
  92         m_avg_rtt_timer = 0.0;
  93         m_playerpos_send_timer = 0.0;
  94
  95         //m_fetchblock_mutex.Init();
  96         m_incoming_queue_mutex.Init();
  97         m_env_mutex.Init();
  98         m_con_mutex.Init();
  99         m_step_dtime_mutex.Init();
 100
 101         m_thread.Start();
 102
 103         {
 104                 JMutexAutoLock envlock(m_env_mutex);
 105                 //m_env.getMap().StartUpdater();
 106
 107                 Player *player = new LocalPlayer();
 108
 109                 player->updateName(playername);
 110
 111                 /*f32 y = BS*2 + BS*20;
 112                 player->setPosition(v3f(0, y, 0));*/
 113                 //player->setPosition(v3f(0, y, 30900*BS)); // DEBUG
 114                 m_env.addPlayer(player);
 115         }
 116 }
 117
 118 Client::~Client()
 119 {
 120         m_thread.setRun(false);
 121         while(m_thread.IsRunning())
 122                 sleep_ms(100);
 123 }
 124
 125 void Client::connect(Address address)
 126 {
 127         DSTACK(__FUNCTION_NAME);
 128         JMutexAutoLock lock(m_con_mutex);
 129         m_con.setTimeoutMs(0);
 130         m_con.Connect(address);
 131 }
 132
 133 bool Client::connectedAndInitialized()
 134 {
 135         JMutexAutoLock lock(m_con_mutex);
 136
 137         if(m_con.Connected() == false)
 138                 return false;
 139
 140         if(m_server_ser_ver == SER_FMT_VER_INVALID)
 141                 return false;
 142
 143         return true;
 144 }
 145
 146 void Client::step(float dtime)
 147 {
 148         DSTACK(__FUNCTION_NAME);
 149
 150         // Limit a bit
 151         if(dtime > 2.0)
 152                 dtime = 2.0;
 153
 154         /*
 155                 Day/night
 156         */
 157         {
 158                 s32 d = 8;
 159                 s32 t = (((m_time_of_day.get() + 24000/d/2)%24000)/(24000/d));
 160                 s32 dn = 0;
 161                 if(t == d/4 || t == (d-d/4))
 162                         dn = 1;
 163                 else if(t < d/4 || t > (d-d/4))
 164                         dn = 2;
 165                 else
 166                         dn = 0;
 167
 168                 u32 dr = 1000;
 169                 if(dn == 0)
 170                         dr = 1000;
 171                 if(dn == 1)
 172                         dr = 600;
 173                 if(dn == 2)
 174                         dr = 300;
 175
 176                 if(dr != m_env.getDayNightRatio())
 177                 {
 178                         //dstream<<"dr="<<dr<<std::endl;
 179                         dout_client<<DTIME<<"Client: changing day-night ratio"<<std::endl;
 180                         m_env.setDayNightRatio(dr);
 181                         m_env.expireMeshes(true);
 182                 }
 183         }
 184
 185
 186         //dstream<<"Client steps "<<dtime<<std::endl;
 187
 188         {
 189                 //TimeTaker timer("ReceiveAll()", m_device);
 190                 // 0ms
 191                 ReceiveAll();
 192         }
 193
 194         {
 195                 //TimeTaker timer("m_con_mutex + m_con.RunTimeouts()", m_device);
 196                 // 0ms
 197                 JMutexAutoLock lock(m_con_mutex);
 198                 m_con.RunTimeouts(dtime);
 199         }
 200
 201         /*
 202                 Packet counter
 203         */
 204         {
 205                 float &counter = m_packetcounter_timer;
 206                 counter -= dtime;
 207                 if(counter <= 0.0)
 208                 {
 209                         counter = 20.0;
 210
 211                         dout_client<<"Client packetcounter (20s):"<<std::endl;
 212                         m_packetcounter.print(dout_client);
 213                         m_packetcounter.clear();
 214                 }
 215         }
 216
 217         {
 218                 /*
 219                         Delete unused sectors
 220
 221                         NOTE: This jams the game for a while because deleting sectors
 222                               clear caches
 223                 */
 224
 225                 float &counter = m_delete_unused_sectors_timer;
 226                 counter -= dtime;
 227                 if(counter <= 0.0)
 228                 {
 229                         // 3 minute interval
 230                         //counter = 180.0;
 231                         counter = 60.0;
 232
 233                         JMutexAutoLock lock(m_env_mutex);
 234
 235                         core::list<v3s16> deleted_blocks;
 236
 237                         float delete_unused_sectors_timeout =
 238                                 g_settings.getFloat("client_delete_unused_sectors_timeout");
 239
 240                         // Delete sector blocks
 241                         /*u32 num = m_env.getMap().deleteUnusedSectors
 242                                         (delete_unused_sectors_timeout,
 243                                         true, &deleted_blocks);*/
 244
 245                         // Delete whole sectors
 246                         u32 num = m_env.getMap().deleteUnusedSectors
 247                                         (delete_unused_sectors_timeout,
 248                                         false, &deleted_blocks);
 249
 250                         if(num > 0)
 251                         {
 252                                 /*dstream<<DTIME<<"Client: Deleted blocks of "<<num
 253                                                 <<" unused sectors"<<std::endl;*/
 254                                 dstream<<DTIME<<"Client: Deleted "<<num
 255                                                 <<" unused sectors"<<std::endl;
 256
 257                                 /*
 258                                         Send info to server
 259                                 */
 260
 261                                 // Env is locked so con can be locked.
 262                                 JMutexAutoLock lock(m_con_mutex);
 263
 264                                 core::list<v3s16>::Iterator i = deleted_blocks.begin();
 265                                 core::list<v3s16> sendlist;
 266                                 for(;;)
 267                                 {
 268                                         if(sendlist.size() == 255 || i == deleted_blocks.end())
 269                                         {
 270                                                 if(sendlist.size() == 0)
 271                                                         break;
 272                                                 /*
 273                                                         [0] u16 command
 274                                                         [2] u8 count
 275                                                         [3] v3s16 pos_0
 276                                                         [3+6] v3s16 pos_1
 277                                                         ...
 278                                                 */
 279                                                 u32 replysize = 2+1+6*sendlist.size();
 280                                                 SharedBuffer<u8> reply(replysize);
 281                                                 writeU16(&reply[0], TOSERVER_DELETEDBLOCKS);
 282                                                 reply[2] = sendlist.size();
 283                                                 u32 k = 0;
 284                                                 for(core::list<v3s16>::Iterator
 285                                                                 j = sendlist.begin();
 286                                                                 j != sendlist.end(); j++)
 287                                                 {
 288                                                         writeV3S16(&reply[2+1+6*k], *j);
 289                                                         k++;
 290                                                 }
 291                                                 m_con.Send(PEER_ID_SERVER, 1, reply, true);
 292
 293                                                 if(i == deleted_blocks.end())
 294                                                         break;
 295
 296                                                 sendlist.clear();
 297                                         }
 298
 299                                         sendlist.push_back(*i);
 300                                         i++;
 301                                 }
 302                         }
 303                 }
 304         }
 305
 306         bool connected = connectedAndInitialized();
 307
 308         if(connected == false)
 309         {
 310                 float &counter = m_connection_reinit_timer;
 311                 counter -= dtime;
 312                 if(counter <= 0.0)
 313                 {
 314                         counter = 2.0;
 315
 316                         JMutexAutoLock envlock(m_env_mutex);
 317
 318                         Player *myplayer = m_env.getLocalPlayer();
 319                         assert(myplayer != NULL);
 320
 321                         // Send TOSERVER_INIT
 322                         // [0] u16 TOSERVER_INIT
 323                         // [2] u8 SER_FMT_VER_HIGHEST
 324                         // [3] u8[20] player_name
 325                         SharedBuffer<u8> data(2+1+20);
 326                         writeU16(&data[0], TOSERVER_INIT);
 327                         writeU8(&data[2], SER_FMT_VER_HIGHEST);
 328                         memcpy(&data[3], myplayer->getName(), 20);
 329                         // Send as unreliable
 330                         Send(0, data, false);
 331                 }
 332
 333                 // Not connected, return
 334                 return;
 335         }
 336
 337         /*
 338                 Do stuff if connected
 339         */
 340
 341         {
 342                 // 0ms
 343                 JMutexAutoLock lock(m_env_mutex);
 344
 345                 // Control local player (0ms)
 346                 LocalPlayer *player = m_env.getLocalPlayer();
 347                 assert(player != NULL);
 348                 player->applyControl(dtime);
 349
 350                 //TimeTaker envtimer("env step", m_device);
 351                 // Step environment
 352                 m_env.step(dtime);
 353
 354                 // Step active blocks
 355                 for(core::map<v3s16, bool>::Iterator
 356                                 i = m_active_blocks.getIterator();
 357                                 i.atEnd() == false; i++)
 358                 {
 359                         v3s16 p = i.getNode()->getKey();
 360
 361                         MapBlock *block = NULL;
 362                         try
 363                         {
 364                                 block = m_env.getMap().getBlockNoCreate(p);
 365                                 block->stepObjects(dtime, false, m_env.getDayNightRatio());
 366                         }
 367                         catch(InvalidPositionException &e)
 368                         {
 369                         }
 370                 }
 371         }
 372
 373         {
 374                 float &counter = m_avg_rtt_timer;
 375                 counter += dtime;
 376                 if(counter >= 10)
 377                 {
 378                         counter = 0.0;
 379                         JMutexAutoLock lock(m_con_mutex);
 380                         // connectedAndInitialized() is true, peer exists.
 381                         con::Peer *peer = m_con.GetPeer(PEER_ID_SERVER);
 382                         dstream<<DTIME<<"Client: avg_rtt="<<peer->avg_rtt<<std::endl;
 383                 }
 384         }
 385         {
 386                 float &counter = m_playerpos_send_timer;
 387                 counter += dtime;
 388                 if(counter >= 0.2)
 389                 {
 390                         counter = 0.0;
 391                         sendPlayerPos();
 392                 }
 393         }
 394
 395         /*{
 396                 JMutexAutoLock lock(m_step_dtime_mutex);
 397                 m_step_dtime += dtime;
 398         }*/
 399 }
 400
 401 float Client::asyncStep()
 402 {
 403         DSTACK(__FUNCTION_NAME);
 404         //dstream<<"Client::asyncStep()"<<std::endl;
 405
 406         /*float dtime;
 407         {
 408                 JMutexAutoLock lock1(m_step_dtime_mutex);
 409                 if(m_step_dtime < 0.001)
 410                         return 0.0;
 411                 dtime = m_step_dtime;
 412                 m_step_dtime = 0.0;
 413         }
 414
 415         return dtime;*/
 416         return 0.0;
 417 }
 418
 419 // Virtual methods from con::PeerHandler
 420 void Client::peerAdded(con::Peer *peer)
 421 {
 422         derr_client<<"Client::peerAdded(): peer->id="
 423                         <<peer->id<<std::endl;
 424 }
 425 void Client::deletingPeer(con::Peer *peer, bool timeout)
 426 {
 427         derr_client<<"Client::deletingPeer(): "
 428                         "Server Peer is getting deleted "
 429                         <<"(timeout="<<timeout<<")"<<std::endl;
 430 }
 431
 432 void Client::ReceiveAll()
 433 {
 434         DSTACK(__FUNCTION_NAME);
 435         for(;;)
 436         {
 437                 try{
 438                         Receive();
 439                 }
 440                 catch(con::NoIncomingDataException &e)
 441                 {
 442                         break;
 443                 }
 444                 catch(con::InvalidIncomingDataException &e)
 445                 {
 446                         dout_client<<DTIME<<"Client::ReceiveAll(): "
 447                                         "InvalidIncomingDataException: what()="
 448                                         <<e.what()<<std::endl;
 449                 }
 450         }
 451 }
 452
 453 void Client::Receive()
 454 {
 455         DSTACK(__FUNCTION_NAME);
 456         u32 data_maxsize = 10000;
 457         Buffer<u8> data(data_maxsize);
 458         u16 sender_peer_id;
 459         u32 datasize;
 460         {
 461                 //TimeTaker t1("con mutex and receive", m_device);
 462                 JMutexAutoLock lock(m_con_mutex);
 463                 datasize = m_con.Receive(sender_peer_id, *data, data_maxsize);
 464         }
 465         //TimeTaker t1("ProcessData", m_device);
 466         ProcessData(*data, datasize, sender_peer_id);
 467 }
 468
 469 /*
 470         sender_peer_id given to this shall be quaranteed to be a valid peer
 471 */
 472 void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id)
 473 {
 474         DSTACK(__FUNCTION_NAME);
 475
 476         // Ignore packets that don't even fit a command
 477         if(datasize < 2)
 478         {
 479                 m_packetcounter.add(60000);
 480                 return;
 481         }
 482
 483         ToClientCommand command = (ToClientCommand)readU16(&data[0]);
 484
 485         //dstream<<"Client: received command="<<command<<std::endl;
 486         m_packetcounter.add((u16)command);
 487
 488         /*
 489                 If this check is removed, be sure to change the queue
 490                 system to know the ids
 491         */
 492         if(sender_peer_id != PEER_ID_SERVER)
 493         {
 494                 dout_client<<DTIME<<"Client::ProcessData(): Discarding data not "
 495                                 "coming from server: peer_id="<<sender_peer_id
 496                                 <<std::endl;
 497                 return;
 498         }
 499
 500         con::Peer *peer;
 501         {
 502                 JMutexAutoLock lock(m_con_mutex);
 503                 // All data is coming from the server
 504                 // PeerNotFoundException is handled by caller.
 505                 peer = m_con.GetPeer(PEER_ID_SERVER);
 506         }
 507
 508         u8 ser_version = m_server_ser_ver;
 509
 510         //dstream<<"Client received command="<<(int)command<<std::endl;
 511
 512         // Execute fast commands straight away
 513
 514         if(command == TOCLIENT_INIT)
 515         {
 516                 if(datasize < 3)
 517                         return;
 518
 519                 u8 deployed = data[2];
 520
 521                 dout_client<<DTIME<<"Client: TOCLIENT_INIT received with "
 522                                 "deployed="<<((int)deployed&0xff)<<std::endl;
 523
 524                 if(deployed < SER_FMT_VER_LOWEST
 525                                 || deployed > SER_FMT_VER_HIGHEST)
 526                 {
 527                         derr_client<<DTIME<<"Client: TOCLIENT_INIT: Server sent "
 528                                         <<"unsupported ser_fmt_ver"<<std::endl;
 529                         return;
 530                 }
 531
 532                 m_server_ser_ver = deployed;
 533
 534                 // Get player position
 535                 v3s16 playerpos_s16(0, BS*2+BS*20, 0);
 536                 if(datasize >= 2+1+6)
 537                         playerpos_s16 = readV3S16(&data[2+1]);
 538                 v3f playerpos_f = intToFloat(playerpos_s16) - v3f(0, BS/2, 0);
 539
 540                 { //envlock
 541                         JMutexAutoLock envlock(m_env_mutex);
 542
 543                         // Set player position
 544                         Player *player = m_env.getLocalPlayer();
 545                         assert(player != NULL);
 546                         player->setPosition(playerpos_f);
 547                 }
 548
 549                 // Reply to server
 550                 u32 replysize = 2;
 551                 SharedBuffer<u8> reply(replysize);
 552                 writeU16(&reply[0], TOSERVER_INIT2);
 553                 // Send as reliable
 554                 m_con.Send(PEER_ID_SERVER, 1, reply, true);
 555
 556                 return;
 557         }
 558
 559         if(ser_version == SER_FMT_VER_INVALID)
 560         {
 561                 dout_client<<DTIME<<"WARNING: Client: Server serialization"
 562                                 " format invalid or not initialized."
 563                                 " Skipping incoming command="<<command<<std::endl;
 564                 return;
 565         }
 566
 567         // Just here to avoid putting the two if's together when
 568         // making some copypasta
 569         {}
 570
 571         if(command == TOCLIENT_REMOVENODE)
 572         {
 573                 if(datasize < 8)
 574                         return;
 575                 v3s16 p;
 576                 p.X = readS16(&data[2]);
 577                 p.Y = readS16(&data[4]);
 578                 p.Z = readS16(&data[6]);
 579
 580                 //TimeTaker t1("TOCLIENT_REMOVENODE", g_device);
 581
 582                 // This will clear the cracking animation after digging
 583                 ((ClientMap&)m_env.getMap()).clearTempMod(p);
 584
 585                 removeNode(p);
 586         }
 587         else if(command == TOCLIENT_ADDNODE)
 588         {
 589                 if(datasize < 8 + MapNode::serializedLength(ser_version))
 590                         return;
 591
 592                 v3s16 p;
 593                 p.X = readS16(&data[2]);
 594                 p.Y = readS16(&data[4]);
 595                 p.Z = readS16(&data[6]);
 596
 597                 //TimeTaker t1("TOCLIENT_ADDNODE", g_device);
 598
 599                 MapNode n;
 600                 n.deSerialize(&data[8], ser_version);
 601
 602                 addNode(p, n);
 603         }
 604         if(command == TOCLIENT_PLAYERPOS)
 605         {
 606                 dstream<<"WARNING: Received deprecated TOCLIENT_PLAYERPOS"
 607                                 <<std::endl;
 608                 /*u16 our_peer_id;
 609                 {
 610                         JMutexAutoLock lock(m_con_mutex);
 611                         our_peer_id = m_con.GetPeerID();
 612                 }
 613                 // Cancel if we don't have a peer id
 614                 if(our_peer_id == PEER_ID_NEW){
 615                         dout_client<<DTIME<<"TOCLIENT_PLAYERPOS cancelled: "
 616                                         "we have no peer id"
 617                                         <<std::endl;
 618                         return;
 619                 }*/
 620
 621                 { //envlock
 622                         JMutexAutoLock envlock(m_env_mutex);
 623
 624                         u32 player_size = 2+12+12+4+4;
 625
 626                         u32 player_count = (datasize-2) / player_size;
 627                         u32 start = 2;
 628                         for(u32 i=0; i<player_count; i++)
 629                         {
 630                                 u16 peer_id = readU16(&data[start]);
 631
 632                                 Player *player = m_env.getPlayer(peer_id);
 633
 634                                 // Skip if player doesn't exist
 635                                 if(player == NULL)
 636                                 {
 637                                         start += player_size;
 638                                         continue;
 639                                 }
 640
 641                                 // Skip if player is local player
 642                                 if(player->isLocal())
 643                                 {
 644                                         start += player_size;
 645                                         continue;
 646                                 }
 647
 648                                 v3s32 ps = readV3S32(&data[start+2]);
 649                                 v3s32 ss = readV3S32(&data[start+2+12]);
 650                                 s32 pitch_i = readS32(&data[start+2+12+12]);
 651                                 s32 yaw_i = readS32(&data[start+2+12+12+4]);
 652                                 /*dstream<<"Client: got "
 653                                                 <<"pitch_i="<<pitch_i
 654                                                 <<" yaw_i="<<yaw_i<<std::endl;*/
 655                                 f32 pitch = (f32)pitch_i / 100.0;
 656                                 f32 yaw = (f32)yaw_i / 100.0;
 657                                 v3f position((f32)ps.X/100., (f32)ps.Y/100., (f32)ps.Z/100.);
 658                                 v3f speed((f32)ss.X/100., (f32)ss.Y/100., (f32)ss.Z/100.);
 659                                 player->setPosition(position);
 660                                 player->setSpeed(speed);
 661                                 player->setPitch(pitch);
 662                                 player->setYaw(yaw);
 663
 664                                 /*dstream<<"Client: player "<<peer_id
 665                                                 <<" pitch="<<pitch
 666                                                 <<" yaw="<<yaw<<std::endl;*/
 667
 668                                 start += player_size;
 669                         }
 670                 } //envlock
 671         }
 672         else if(command == TOCLIENT_PLAYERINFO)
 673         {
 674                 u16 our_peer_id;
 675                 {
 676                         JMutexAutoLock lock(m_con_mutex);
 677                         our_peer_id = m_con.GetPeerID();
 678                 }
 679                 // Cancel if we don't have a peer id
 680                 if(our_peer_id == PEER_ID_NEW){
 681                         dout_client<<DTIME<<"TOCLIENT_PLAYERINFO cancelled: "
 682                                         "we have no peer id"
 683                                         <<std::endl;
 684                         return;
 685                 }
 686
 687                 //dstream<<DTIME<<"Client: Server reports players:"<<std::endl;
 688
 689                 { //envlock
 690                         JMutexAutoLock envlock(m_env_mutex);
 691
 692                         u32 item_size = 2+PLAYERNAME_SIZE;
 693                         u32 player_count = (datasize-2) / item_size;
 694                         u32 start = 2;
 695                         // peer_ids
 696                         core::list<u16> players_alive;
 697                         for(u32 i=0; i<player_count; i++)
 698                         {
 699                                 // Make sure the name ends in '\0'
 700                                 data[start+2+20-1] = 0;
 701
 702                                 u16 peer_id = readU16(&data[start]);
 703
 704                                 players_alive.push_back(peer_id);
 705
 706                                 /*dstream<<DTIME<<"peer_id="<<peer_id
 707                                                 <<" name="<<((char*)&data[start+2])<<std::endl;*/
 708
 709                                 // Don't update the info of the local player
 710                                 if(peer_id == our_peer_id)
 711                                 {
 712                                         start += item_size;
 713                                         continue;
 714                                 }
 715
 716                                 Player *player = m_env.getPlayer(peer_id);
 717
 718                                 // Create a player if it doesn't exist
 719                                 if(player == NULL)
 720                                 {
 721                                         player = new RemotePlayer(
 722                                                         m_device->getSceneManager()->getRootSceneNode(),
 723                                                         m_device,
 724                                                         -1);
 725                                         player->peer_id = peer_id;
 726                                         m_env.addPlayer(player);
 727                                         dout_client<<DTIME<<"Client: Adding new player "
 728                                                         <<peer_id<<std::endl;
 729                                 }
 730
 731                                 player->updateName((char*)&data[start+2]);
 732
 733                                 start += item_size;
 734                         }
 735
 736                         /*
 737                                 Remove those players from the environment that
 738                                 weren't listed by the server.
 739                         */
 740                         //dstream<<DTIME<<"Removing dead players"<<std::endl;
 741                         core::list<Player*> players = m_env.getPlayers();
 742                         core::list<Player*>::Iterator ip;
 743                         for(ip=players.begin(); ip!=players.end(); ip++)
 744                         {
 745                                 // Ingore local player
 746                                 if((*ip)->isLocal())
 747                                         continue;
 748
 749                                 // Warn about a special case
 750                                 if((*ip)->peer_id == 0)
 751                                 {
 752                                         dstream<<DTIME<<"WARNING: Client: Removing "
 753                                                         "dead player with id=0"<<std::endl;
 754                                 }
 755
 756                                 bool is_alive = false;
 757                                 core::list<u16>::Iterator i;
 758                                 for(i=players_alive.begin(); i!=players_alive.end(); i++)
 759                                 {
 760                                         if((*ip)->peer_id == *i)
 761                                         {
 762                                                 is_alive = true;
 763                                                 break;
 764                                         }
 765                                 }
 766                                 /*dstream<<DTIME<<"peer_id="<<((*ip)->peer_id)
 767                                                 <<" is_alive="<<is_alive<<std::endl;*/
 768                                 if(is_alive)
 769                                         continue;
 770                                 dstream<<DTIME<<"Removing dead player "<<(*ip)->peer_id
 771                                                 <<std::endl;
 772                                 m_env.removePlayer((*ip)->peer_id);
 773                         }
 774                 } //envlock
 775         }
 776         else if(command == TOCLIENT_SECTORMETA)
 777         {
 778                 /*
 779                         [0] u16 command
 780                         [2] u8 sector count
 781                         [3...] v2s16 pos + sector metadata
 782                 */
 783                 if(datasize < 3)
 784                         return;
 785
 786                 //dstream<<"Client received TOCLIENT_SECTORMETA"<<std::endl;
 787
 788                 { //envlock
 789                         JMutexAutoLock envlock(m_env_mutex);
 790
 791                         std::string datastring((char*)&data[2], datasize-2);
 792                         std::istringstream is(datastring, std::ios_base::binary);
 793
 794                         u8 buf[4];
 795
 796                         is.read((char*)buf, 1);
 797                         u16 sector_count = readU8(buf);
 798
 799                         //dstream<<"sector_count="<<sector_count<<std::endl;
 800
 801                         for(u16 i=0; i<sector_count; i++)
 802                         {
 803                                 // Read position
 804                                 is.read((char*)buf, 4);
 805                                 v2s16 pos = readV2S16(buf);
 806                                 /*dstream<<"Client: deserializing sector at "
 807                                                 <<"("<<pos.X<<","<<pos.Y<<")"<<std::endl;*/
 808                                 // Create sector
 809                                 assert(m_env.getMap().mapType() == MAPTYPE_CLIENT);
 810                                 ((ClientMap&)m_env.getMap()).deSerializeSector(pos, is);
 811                         }
 812                 } //envlock
 813         }
 814         else if(command == TOCLIENT_INVENTORY)
 815         {
 816                 if(datasize < 3)
 817                         return;
 818
 819                 //TimeTaker t1("Parsing TOCLIENT_INVENTORY", m_device);
 820
 821                 { //envlock
 822                         //TimeTaker t2("mutex locking", m_device);
 823                         JMutexAutoLock envlock(m_env_mutex);
 824                         //t2.stop();
 825
 826                         //TimeTaker t3("istringstream init", m_device);
 827                         std::string datastring((char*)&data[2], datasize-2);
 828                         std::istringstream is(datastring, std::ios_base::binary);
 829                         //t3.stop();
 830
 831                         //m_env.printPlayers(dstream);
 832
 833                         //TimeTaker t4("player get", m_device);
 834                         Player *player = m_env.getLocalPlayer();
 835                         assert(player != NULL);
 836                         //t4.stop();
 837
 838                         //TimeTaker t1("inventory.deSerialize()", m_device);
 839                         player->inventory.deSerialize(is);
 840                         //t1.stop();
 841
 842                         m_inventory_updated = true;
 843
 844                         //dstream<<"Client got player inventory:"<<std::endl;
 845                         //player->inventory.print(dstream);
 846                 }
 847         }
 848         //DEBUG
 849         else if(command == TOCLIENT_OBJECTDATA)
 850         //else if(0)
 851         {
 852                 // Strip command word and create a stringstream
 853                 std::string datastring((char*)&data[2], datasize-2);
 854                 std::istringstream is(datastring, std::ios_base::binary);
 855
 856                 { //envlock
 857
 858                 JMutexAutoLock envlock(m_env_mutex);
 859
 860                 u8 buf[12];
 861
 862                 /*
 863                         Read players
 864                 */
 865
 866                 is.read((char*)buf, 2);
 867                 u16 playercount = readU16(buf);
 868
 869                 for(u16 i=0; i<playercount; i++)
 870                 {
 871                         is.read((char*)buf, 2);
 872                         u16 peer_id = readU16(buf);
 873                         is.read((char*)buf, 12);
 874                         v3s32 p_i = readV3S32(buf);
 875                         is.read((char*)buf, 12);
 876                         v3s32 s_i = readV3S32(buf);
 877                         is.read((char*)buf, 4);
 878                         s32 pitch_i = readS32(buf);
 879                         is.read((char*)buf, 4);
 880                         s32 yaw_i = readS32(buf);
 881
 882                         Player *player = m_env.getPlayer(peer_id);
 883
 884                         // Skip if player doesn't exist
 885                         if(player == NULL)
 886                         {
 887                                 continue;
 888                         }
 889
 890                         // Skip if player is local player
 891                         if(player->isLocal())
 892                         {
 893                                 continue;
 894                         }
 895
 896                         f32 pitch = (f32)pitch_i / 100.0;
 897                         f32 yaw = (f32)yaw_i / 100.0;
 898                         v3f position((f32)p_i.X/100., (f32)p_i.Y/100., (f32)p_i.Z/100.);
 899                         v3f speed((f32)s_i.X/100., (f32)s_i.Y/100., (f32)s_i.Z/100.);
 900
 901                         player->setPosition(position);
 902                         player->setSpeed(speed);
 903                         player->setPitch(pitch);
 904                         player->setYaw(yaw);
 905                 }
 906
 907                 /*
 908                         Read block objects
 909                 */
 910
 911                 // Read active block count
 912                 is.read((char*)buf, 2);
 913                 u16 blockcount = readU16(buf);
 914
 915                 // Initialize delete queue with all active blocks
 916                 core::map<v3s16, bool> abs_to_delete;
 917                 for(core::map<v3s16, bool>::Iterator
 918                                 i = m_active_blocks.getIterator();
 919                                 i.atEnd() == false; i++)
 920                 {
 921                         v3s16 p = i.getNode()->getKey();
 922                         /*dstream<<"adding "
 923                                         <<"("<<p.x<<","<<p.y<<","<<p.z<<") "
 924                                         <<" to abs_to_delete"
 925                                         <<std::endl;*/
 926                         abs_to_delete.insert(p, true);
 927                 }
 928
 929                 /*dstream<<"Initial delete queue size: "<<abs_to_delete.size()
 930                                 <<std::endl;*/
 931
 932                 for(u16 i=0; i<blockcount; i++)
 933                 {
 934                         // Read blockpos
 935                         is.read((char*)buf, 6);
 936                         v3s16 p = readV3S16(buf);
 937                         // Get block from somewhere
 938                         MapBlock *block = NULL;
 939                         try{
 940                                 block = m_env.getMap().getBlockNoCreate(p);
 941                         }
 942                         catch(InvalidPositionException &e)
 943                         {
 944                                 //TODO: Create a dummy block?
 945                         }
 946                         if(block == NULL)
 947                         {
 948                                 dstream<<"WARNING: "
 949                                                 <<"Could not get block at blockpos "
 950                                                 <<"("<<p.X<<","<<p.Y<<","<<p.Z<<") "
 951                                                 <<"in TOCLIENT_OBJECTDATA. Ignoring "
 952                                                 <<"following block object data."
 953                                                 <<std::endl;
 954                                 return;
 955                         }
 956
 957                         /*dstream<<"Client updating objects for block "
 958                                         <<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"
 959                                         <<std::endl;*/
 960
 961                         // Insert to active block list
 962                         m_active_blocks.insert(p, true);
 963
 964                         // Remove from deletion queue
 965                         if(abs_to_delete.find(p) != NULL)
 966                                 abs_to_delete.remove(p);
 967
 968                         /*
 969                                 Update objects of block
 970
 971                                 NOTE: Be sure this is done in the main thread.
 972                         */
 973                         block->updateObjects(is, m_server_ser_ver,
 974                                         m_device->getSceneManager(), m_env.getDayNightRatio());
 975                 }
 976
 977                 /*dstream<<"Final delete queue size: "<<abs_to_delete.size()
 978                                 <<std::endl;*/
 979
 980                 // Delete objects of blocks in delete queue
 981                 for(core::map<v3s16, bool>::Iterator
 982                                 i = abs_to_delete.getIterator();
 983                                 i.atEnd() == false; i++)
 984                 {
 985                         v3s16 p = i.getNode()->getKey();
 986                         try
 987                         {
 988                                 MapBlock *block = m_env.getMap().getBlockNoCreate(p);
 989
 990                                 // Clear objects
 991                                 block->clearObjects();
 992                                 // Remove from active blocks list
 993                                 m_active_blocks.remove(p);
 994                         }
 995                         catch(InvalidPositionException &e)
 996                         {
 997                                 dstream<<"WARNAING: Client: "
 998                                                 <<"Couldn't clear objects of active->inactive"
 999                                                 <<" block "
1000                                                 <<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"
1001                                                 <<" because block was not found"
1002                                                 <<std::endl;
1003                                 // Ignore
1004                         }
1005                 }
1006
1007                 } //envlock
1008         }
1009         else if(command == TOCLIENT_TIME_OF_DAY)
1010         {
1011                 if(datasize < 4)
1012                         return;
1013
1014                 u16 time = readU16(&data[2]);
1015                 time = time % 24000;
1016                 m_time_of_day.set(time);
1017                 //dstream<<"Client: time="<<time<<std::endl;
1018         }
1019         else if(command == TOCLIENT_CHAT_MESSAGE)
1020         {
1021                 /*
1022                         u16 command
1023                         u16 length
1024                         wstring message
1025                 */
1026                 u8 buf[6];
1027                 std::string datastring((char*)&data[2], datasize-2);
1028                 std::istringstream is(datastring, std::ios_base::binary);
1029
1030                 // Read stuff
1031                 is.read((char*)buf, 2);
1032                 u16 len = readU16(buf);
1033
1034                 std::wstring message;
1035                 for(u16 i=0; i<len; i++)
1036                 {
1037                         is.read((char*)buf, 2);
1038                         message += (wchar_t)readU16(buf);
1039                 }
1040
1041                 /*dstream<<"Client received chat message: "
1042                                 <<wide_to_narrow(message)<<std::endl;*/
1043
1044                 m_chat_queue.push_back(message);
1045         }
1046         // Default to queueing it (for slow commands)
1047         else
1048         {
1049                 JMutexAutoLock lock(m_incoming_queue_mutex);
1050
1051                 IncomingPacket packet(data, datasize);
1052                 m_incoming_queue.push_back(packet);
1053         }
1054 }
1055
1056 /*
1057         Returns true if there was something in queue
1058 */
1059 bool Client::AsyncProcessPacket()
1060 {
1061         DSTACK(__FUNCTION_NAME);
1062
1063         try //for catching con::PeerNotFoundException
1064         {
1065
1066         con::Peer *peer;
1067         {
1068                 JMutexAutoLock lock(m_con_mutex);
1069                 // All data is coming from the server
1070                 peer = m_con.GetPeer(PEER_ID_SERVER);
1071         }
1072
1073         u8 ser_version = m_server_ser_ver;
1074
1075         IncomingPacket packet = getPacket();
1076         u8 *data = packet.m_data;
1077         u32 datasize = packet.m_datalen;
1078
1079         // An empty packet means queue is empty
1080         if(data == NULL){
1081                 return false;
1082         }
1083
1084         if(datasize < 2)
1085                 return true;
1086
1087         ToClientCommand command = (ToClientCommand)readU16(&data[0]);
1088
1089         if(command == TOCLIENT_BLOCKDATA)
1090         {
1091                 // Ignore too small packet
1092                 if(datasize < 8)
1093                         return true;
1094                 /*if(datasize < 8 + MapBlock::serializedLength(ser_version))
1095                         goto getdata;*/
1096
1097                 v3s16 p;
1098                 p.X = readS16(&data[2]);
1099                 p.Y = readS16(&data[4]);
1100                 p.Z = readS16(&data[6]);
1101
1102                 /*dout_client<<DTIME<<"Client: Thread: BLOCKDATA for ("
1103                                 <<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;*/
1104
1105                 /*dstream<<DTIME<<"Client: Thread: BLOCKDATA for ("
1106                                 <<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;*/
1107
1108                 std::string datastring((char*)&data[8], datasize-8);
1109                 std::istringstream istr(datastring, std::ios_base::binary);
1110
1111                 MapSector *sector;
1112                 MapBlock *block;
1113
1114                 { //envlock
1115                         JMutexAutoLock envlock(m_env_mutex);
1116
1117                         v2s16 p2d(p.X, p.Z);
1118                         sector = m_env.getMap().emergeSector(p2d);
1119
1120                         v2s16 sp = sector->getPos();
1121                         if(sp != p2d)
1122                         {
1123                                 dstream<<"ERROR: Got sector with getPos()="
1124                                                 <<"("<<sp.X<<","<<sp.Y<<"), tried to get"
1125                                                 <<"("<<p2d.X<<","<<p2d.Y<<")"<<std::endl;
1126                         }
1127
1128                         assert(sp == p2d);
1129                         //assert(sector->getPos() == p2d);
1130
1131                         try{
1132                                 block = sector->getBlockNoCreate(p.Y);
1133                                 /*
1134                                         Update an existing block
1135                                 */
1136                                 //dstream<<"Updating"<<std::endl;
1137                                 block->deSerialize(istr, ser_version);
1138                                 //block->setChangedFlag();
1139                         }
1140                         catch(InvalidPositionException &e)
1141                         {
1142                                 /*
1143                                         Create a new block
1144                                 */
1145                                 //dstream<<"Creating new"<<std::endl;
1146                                 block = new MapBlock(&m_env.getMap(), p);
1147                                 block->deSerialize(istr, ser_version);
1148                                 sector->insertBlock(block);
1149                                 //block->setChangedFlag();
1150
1151                                 //DEBUG
1152                                 /*NodeMod mod;
1153                                 mod.type = NODEMOD_CHANGECONTENT;
1154                                 mod.param = CONTENT_MESE;
1155                                 block->setTempMod(v3s16(8,10,8), mod);
1156                                 block->setTempMod(v3s16(8,9,8), mod);
1157                                 block->setTempMod(v3s16(8,8,8), mod);
1158                                 block->setTempMod(v3s16(8,7,8), mod);
1159                                 block->setTempMod(v3s16(8,6,8), mod);*/
1160
1161                                 /*
1162                                         Add some coulds
1163                                         Well, this is a dumb way to do it, they should just
1164                                         be drawn as separate objects.
1165                                 */
1166                                 /*if(p.Y == 3)
1167                                 {
1168                                         NodeMod mod;
1169                                         mod.type = NODEMOD_CHANGECONTENT;
1170                                         mod.param = CONTENT_CLOUD;
1171                                         v3s16 p2;
1172                                         p2.Y = 8;
1173                                         for(p2.X=3; p2.X<=13; p2.X++)
1174                                         for(p2.Z=3; p2.Z<=13; p2.Z++)
1175                                         {
1176                                                 block->setTempMod(p2, mod);
1177                                         }
1178                                 }*/
1179                         }
1180                 } //envlock
1181
1182                 /*
1183                         Acknowledge block.
1184                 */
1185                 /*
1186                         [0] u16 command
1187                         [2] u8 count
1188                         [3] v3s16 pos_0
1189                         [3+6] v3s16 pos_1
1190                         ...
1191                 */
1192                 u32 replysize = 2+1+6;
1193                 SharedBuffer<u8> reply(replysize);
1194                 writeU16(&reply[0], TOSERVER_GOTBLOCKS);
1195                 reply[2] = 1;
1196                 writeV3S16(&reply[3], p);
1197                 // Send as reliable
1198                 m_con.Send(PEER_ID_SERVER, 1, reply, true);
1199
1200                 /*
1201                         Update Mesh of this block and blocks at x-, y- and z-.
1202                         Environment should not be locked as it interlocks with the
1203                         main thread, from which is will want to retrieve textures.
1204                 */
1205
1206                 m_env.getMap().updateMeshes(block->getPos(), getDayNightRatio());
1207         }
1208         else
1209         {
1210                 dout_client<<DTIME<<"WARNING: Client: Ignoring unknown command "
1211                                 <<command<<std::endl;
1212         }
1213
1214         return true;
1215
1216         } //try
1217         catch(con::PeerNotFoundException &e)
1218         {
1219                 dout_client<<DTIME<<"Client::AsyncProcessData(): Cancelling: The server"
1220                                 " connection doesn't exist (a timeout or not yet connected?)"<<std::endl;
1221                 return false;
1222         }
1223 }
1224
1225 bool Client::AsyncProcessData()
1226 {
1227         for(;;)
1228         {
1229                 bool r = AsyncProcessPacket();
1230                 if(r == false)
1231                         break;
1232         }
1233         return false;
1234 }
1235
1236 void Client::Send(u16 channelnum, SharedBuffer<u8> data, bool reliable)
1237 {
1238         JMutexAutoLock lock(m_con_mutex);
1239         m_con.Send(PEER_ID_SERVER, channelnum, data, reliable);
1240 }
1241
1242 bool Client::isFetchingBlocks()
1243 {
1244         JMutexAutoLock conlock(m_con_mutex);
1245         con::Peer *peer = m_con.GetPeerNoEx(PEER_ID_SERVER);
1246         // Not really fetching but can't fetch more.
1247         if(peer == NULL) return true;
1248
1249         con::Channel *channel = &(peer->channels[1]);
1250         /*
1251                 NOTE: Channel 0 should always be used for fetching blocks,
1252                       and for nothing else.
1253         */
1254         if(channel->incoming_reliables.size() > 0)
1255                 return true;
1256         if(channel->outgoing_reliables.size() > 0)
1257                 return true;
1258         return false;
1259 }
1260
1261 IncomingPacket Client::getPacket()
1262 {
1263         JMutexAutoLock lock(m_incoming_queue_mutex);
1264
1265         core::list<IncomingPacket>::Iterator i;
1266         // Refer to first one
1267         i = m_incoming_queue.begin();
1268
1269         // If queue is empty, return empty packet
1270         if(i == m_incoming_queue.end()){
1271                 IncomingPacket packet;
1272                 return packet;
1273         }
1274
1275         // Pop out first packet and return it
1276         IncomingPacket packet = *i;
1277         m_incoming_queue.erase(i);
1278         return packet;
1279 }
1280
1281 void Client::groundAction(u8 action, v3s16 nodepos_undersurface,
1282                 v3s16 nodepos_oversurface, u16 item)
1283 {
1284         if(connectedAndInitialized() == false){
1285                 dout_client<<DTIME<<"Client::groundAction() "
1286                                 "cancelled (not connected)"
1287                                 <<std::endl;
1288                 return;
1289         }
1290
1291         /*
1292                 length: 17
1293                 [0] u16 command
1294                 [2] u8 action
1295                 [3] v3s16 nodepos_undersurface
1296                 [9] v3s16 nodepos_abovesurface
1297                 [15] u16 item
1298                 actions:
1299                 0: start digging
1300                 1: place block
1301                 2: stop digging (all parameters ignored)
1302         */
1303         u8 datasize = 2 + 1 + 6 + 6 + 2;
1304         SharedBuffer<u8> data(datasize);
1305         writeU16(&data[0], TOSERVER_GROUND_ACTION);
1306         writeU8(&data[2], action);
1307         writeV3S16(&data[3], nodepos_undersurface);
1308         writeV3S16(&data[9], nodepos_oversurface);
1309         writeU16(&data[15], item);
1310         Send(0, data, true);
1311 }
1312
1313 void Client::clickObject(u8 button, v3s16 blockpos, s16 id, u16 item)
1314 {
1315         if(connectedAndInitialized() == false){
1316                 dout_client<<DTIME<<"Client::clickObject() "
1317                                 "cancelled (not connected)"
1318                                 <<std::endl;
1319                 return;
1320         }
1321
1322         /*
1323                 [0] u16 command=TOSERVER_CLICK_OBJECT
1324                 [2] u8 button (0=left, 1=right)
1325                 [3] v3s16 block
1326                 [9] s16 id
1327                 [11] u16 item
1328         */
1329         u8 datasize = 2 + 1 + 6 + 2 + 2;
1330         SharedBuffer<u8> data(datasize);
1331         writeU16(&data[0], TOSERVER_CLICK_OBJECT);
1332         writeU8(&data[2], button);
1333         writeV3S16(&data[3], blockpos);
1334         writeS16(&data[9], id);
1335         writeU16(&data[11], item);
1336         Send(0, data, true);
1337 }
1338
1339 void Client::sendSignText(v3s16 blockpos, s16 id, std::string text)
1340 {
1341         /*
1342                 u16 command
1343                 v3s16 blockpos
1344                 s16 id
1345                 u16 textlen
1346                 textdata
1347         */
1348         std::ostringstream os(std::ios_base::binary);
1349         u8 buf[12];
1350
1351         // Write command
1352         writeU16(buf, TOSERVER_SIGNTEXT);
1353         os.write((char*)buf, 2);
1354
1355         // Write blockpos
1356         writeV3S16(buf, blockpos);
1357         os.write((char*)buf, 6);
1358
1359         // Write id
1360         writeS16(buf, id);
1361         os.write((char*)buf, 2);
1362
1363         u16 textlen = text.size();
1364         // Write text length
1365         writeS16(buf, textlen);
1366         os.write((char*)buf, 2);
1367
1368         // Write text
1369         os.write((char*)text.c_str(), textlen);
1370
1371         // Make data buffer
1372         std::string s = os.str();
1373         SharedBuffer<u8> data((u8*)s.c_str(), s.size());
1374         // Send as reliable
1375         Send(0, data, true);
1376 }
1377
1378 void Client::sendInventoryAction(InventoryAction *a)
1379 {
1380         std::ostringstream os(std::ios_base::binary);
1381         u8 buf[12];
1382
1383         // Write command
1384         writeU16(buf, TOSERVER_INVENTORY_ACTION);
1385         os.write((char*)buf, 2);
1386
1387         a->serialize(os);
1388
1389         // Make data buffer
1390         std::string s = os.str();
1391         SharedBuffer<u8> data((u8*)s.c_str(), s.size());
1392         // Send as reliable
1393         Send(0, data, true);
1394 }
1395
1396 void Client::sendChatMessage(const std::wstring &message)
1397 {
1398         std::ostringstream os(std::ios_base::binary);
1399         u8 buf[12];
1400
1401         // Write command
1402         writeU16(buf, TOSERVER_CHAT_MESSAGE);
1403         os.write((char*)buf, 2);
1404
1405         // Write length
1406         writeU16(buf, message.size());
1407         os.write((char*)buf, 2);
1408
1409         // Write string
1410         for(u32 i=0; i<message.size(); i++)
1411         {
1412                 u16 w = message[i];
1413                 writeU16(buf, w);
1414                 os.write((char*)buf, 2);
1415         }
1416
1417         // Make data buffer
1418         std::string s = os.str();
1419         SharedBuffer<u8> data((u8*)s.c_str(), s.size());
1420         // Send as reliable
1421         Send(0, data, true);
1422 }
1423
1424 void Client::sendPlayerPos()
1425 {
1426         JMutexAutoLock envlock(m_env_mutex);
1427
1428         Player *myplayer = m_env.getLocalPlayer();
1429         if(myplayer == NULL)
1430                 return;
1431
1432         u16 our_peer_id;
1433         {
1434                 JMutexAutoLock lock(m_con_mutex);
1435                 our_peer_id = m_con.GetPeerID();
1436         }
1437
1438         // Set peer id if not set already
1439         if(myplayer->peer_id == PEER_ID_NEW)
1440                 myplayer->peer_id = our_peer_id;
1441         // Check that an existing peer_id is the same as the connection's
1442         assert(myplayer->peer_id == our_peer_id);
1443
1444         v3f pf = myplayer->getPosition();
1445         v3s32 position(pf.X*100, pf.Y*100, pf.Z*100);
1446         v3f sf = myplayer->getSpeed();
1447         v3s32 speed(sf.X*100, sf.Y*100, sf.Z*100);
1448         s32 pitch = myplayer->getPitch() * 100;
1449         s32 yaw = myplayer->getYaw() * 100;
1450
1451         /*
1452                 Format:
1453                 [0] u16 command
1454                 [2] v3s32 position*100
1455                 [2+12] v3s32 speed*100
1456                 [2+12+12] s32 pitch*100
1457                 [2+12+12+4] s32 yaw*100
1458         */
1459
1460         SharedBuffer<u8> data(2+12+12+4+4);
1461         writeU16(&data[0], TOSERVER_PLAYERPOS);
1462         writeV3S32(&data[2], position);
1463         writeV3S32(&data[2+12], speed);
1464         writeS32(&data[2+12+12], pitch);
1465         writeS32(&data[2+12+12+4], yaw);
1466
1467         // Send as unreliable
1468         Send(0, data, false);
1469 }
1470
1471 void Client::removeNode(v3s16 p)
1472 {
1473         JMutexAutoLock envlock(m_env_mutex);
1474
1475         core::map<v3s16, MapBlock*> modified_blocks;
1476
1477         try
1478         {
1479                 //TimeTaker t("removeNodeAndUpdate", m_device);
1480                 m_env.getMap().removeNodeAndUpdate(p, modified_blocks);
1481         }
1482         catch(InvalidPositionException &e)
1483         {
1484         }
1485
1486         for(core::map<v3s16, MapBlock * >::Iterator
1487                         i = modified_blocks.getIterator();
1488                         i.atEnd() == false; i++)
1489         {
1490                 v3s16 p = i.getNode()->getKey();
1491                 m_env.getMap().updateMeshes(p, m_env.getDayNightRatio());
1492         }
1493 }
1494
1495 void Client::addNode(v3s16 p, MapNode n)
1496 {
1497         JMutexAutoLock envlock(m_env_mutex);
1498
1499         core::map<v3s16, MapBlock*> modified_blocks;
1500
1501         try
1502         {
1503                 m_env.getMap().addNodeAndUpdate(p, n, modified_blocks);
1504         }
1505         catch(InvalidPositionException &e)
1506         {}
1507
1508         for(core::map<v3s16, MapBlock * >::Iterator
1509                         i = modified_blocks.getIterator();
1510                         i.atEnd() == false; i++)
1511         {
1512                 v3s16 p = i.getNode()->getKey();
1513                 m_env.getMap().updateMeshes(p, m_env.getDayNightRatio());
1514         }
1515 }
1516
1517 void Client::updateCamera(v3f pos, v3f dir)
1518 {
1519         m_env.getMap().updateCamera(pos, dir);
1520         camera_position = pos;
1521         camera_direction = dir;
1522 }
1523
1524 MapNode Client::getNode(v3s16 p)
1525 {
1526         JMutexAutoLock envlock(m_env_mutex);
1527         return m_env.getMap().getNode(p);
1528 }
1529
1530 /*void Client::getNode(v3s16 p, MapNode n)
1531 {
1532         JMutexAutoLock envlock(m_env_mutex);
1533         m_env.getMap().setNode(p, n);
1534 }*/
1535
1536 /*f32 Client::getGroundHeight(v2s16 p)
1537 {
1538         JMutexAutoLock envlock(m_env_mutex);
1539         return m_env.getMap().getGroundHeight(p);
1540 }*/
1541
1542 /*bool Client::isNodeUnderground(v3s16 p)
1543 {
1544         JMutexAutoLock envlock(m_env_mutex);
1545         return m_env.getMap().isNodeUnderground(p);
1546 }*/
1547
1548 /*Player * Client::getLocalPlayer()
1549 {
1550         JMutexAutoLock envlock(m_env_mutex);
1551         return m_env.getLocalPlayer();
1552 }*/
1553
1554 /*core::list<Player*> Client::getPlayers()
1555 {
1556         JMutexAutoLock envlock(m_env_mutex);
1557         return m_env.getPlayers();
1558 }*/
1559
1560 v3f Client::getPlayerPosition()
1561 {
1562         JMutexAutoLock envlock(m_env_mutex);
1563         LocalPlayer *player = m_env.getLocalPlayer();
1564         assert(player != NULL);
1565         return player->getPosition();
1566 }
1567
1568 void Client::setPlayerControl(PlayerControl &control)
1569 {
1570         JMutexAutoLock envlock(m_env_mutex);
1571         LocalPlayer *player = m_env.getLocalPlayer();
1572         assert(player != NULL);
1573         player->control = control;
1574 }
1575
1576 // Returns true if the inventory of the local player has been
1577 // updated from the server. If it is true, it is set to false.
1578 bool Client::getLocalInventoryUpdated()
1579 {
1580         // m_inventory_updated is behind envlock
1581         JMutexAutoLock envlock(m_env_mutex);
1582         bool updated = m_inventory_updated;
1583         m_inventory_updated = false;
1584         return updated;
1585 }
1586
1587 // Copies the inventory of the local player to parameter
1588 void Client::getLocalInventory(Inventory &dst)
1589 {
1590         JMutexAutoLock envlock(m_env_mutex);
1591         Player *player = m_env.getLocalPlayer();
1592         assert(player != NULL);
1593         dst = player->inventory;
1594 }
1595
1596 MapBlockObject * Client::getSelectedObject(
1597                 f32 max_d,
1598                 v3f from_pos_f_on_map,
1599                 core::line3d<f32> shootline_on_map
1600         )
1601 {
1602         JMutexAutoLock envlock(m_env_mutex);
1603
1604         core::array<DistanceSortedObject> objects;
1605
1606         for(core::map<v3s16, bool>::Iterator
1607                         i = m_active_blocks.getIterator();
1608                         i.atEnd() == false; i++)
1609         {
1610                 v3s16 p = i.getNode()->getKey();
1611
1612                 MapBlock *block = NULL;
1613                 try
1614                 {
1615                         block = m_env.getMap().getBlockNoCreate(p);
1616                 }
1617                 catch(InvalidPositionException &e)
1618                 {
1619                         continue;
1620                 }
1621
1622                 // Calculate from_pos relative to block
1623                 v3s16 block_pos_i_on_map = block->getPosRelative();
1624                 v3f block_pos_f_on_map = intToFloat(block_pos_i_on_map);
1625                 v3f from_pos_f_on_block = from_pos_f_on_map - block_pos_f_on_map;
1626
1627                 block->getObjects(from_pos_f_on_block, max_d, objects);
1628                 //block->getPseudoObjects(from_pos_f_on_block, max_d, objects);
1629         }
1630
1631         //dstream<<"Collected "<<objects.size()<<" nearby objects"<<std::endl;
1632
1633         // Sort them.
1634         // After this, the closest object is the first in the array.
1635         objects.sort();
1636
1637         for(u32 i=0; i<objects.size(); i++)
1638         {
1639                 MapBlockObject *obj = objects[i].obj;
1640                 MapBlock *block = obj->getBlock();
1641
1642                 // Calculate shootline relative to block
1643                 v3s16 block_pos_i_on_map = block->getPosRelative();
1644                 v3f block_pos_f_on_map = intToFloat(block_pos_i_on_map);
1645                 core::line3d<f32> shootline_on_block(
1646                                 shootline_on_map.start - block_pos_f_on_map,
1647                                 shootline_on_map.end - block_pos_f_on_map
1648                 );
1649
1650                 if(obj->isSelected(shootline_on_block))
1651                 {
1652                         //dstream<<"Returning selected object"<<std::endl;
1653                         return obj;
1654                 }
1655         }
1656
1657         //dstream<<"No object selected; returning NULL."<<std::endl;
1658         return NULL;
1659 }
1660
1661 void Client::printDebugInfo(std::ostream &os)
1662 {
1663         //JMutexAutoLock lock1(m_fetchblock_mutex);
1664         JMutexAutoLock lock2(m_incoming_queue_mutex);
1665
1666         os<<"m_incoming_queue.getSize()="<<m_incoming_queue.getSize()
1667                 //<<", m_fetchblock_history.size()="<<m_fetchblock_history.size()
1668                 //<<", m_opt_not_found_history.size()="<<m_opt_not_found_history.size()
1669                 <<std::endl;
1670 }
1671
1672 /*s32 Client::getDayNightIndex()
1673 {
1674         assert(m_daynight_i >= 0 && m_daynight_i < DAYNIGHT_CACHE_COUNT);
1675         return m_daynight_i;
1676 }*/
1677
1678 u32 Client::getDayNightRatio()
1679 {
1680         JMutexAutoLock envlock(m_env_mutex);
1681         return m_env.getDayNightRatio();
1682 }
1683
1684 /*void Client::updateSomeExpiredMeshes()
1685 {
1686         TimeTaker timer("updateSomeExpiredMeshes()", g_device);
1687
1688         Player *player;
1689         {
1690                 JMutexAutoLock envlock(m_env_mutex);
1691                 player = m_env.getLocalPlayer();
1692         }
1693
1694         u32 daynight_ratio = getDayNightRatio();
1695
1696         v3f playerpos = player->getPosition();
1697         v3f playerspeed = player->getSpeed();
1698
1699         v3s16 center_nodepos = floatToInt(playerpos);
1700         v3s16 center = getNodeBlockPos(center_nodepos);
1701
1702         u32 counter = 0;
1703
1704         s16 d_max = 5;
1705
1706         for(s16 d = 0; d <= d_max; d++)
1707         {
1708                 core::list<v3s16> list;
1709                 getFacePositions(list, d);
1710
1711                 core::list<v3s16>::Iterator li;
1712                 for(li=list.begin(); li!=list.end(); li++)
1713                 {
1714                         v3s16 p = *li + center;
1715                         MapBlock *block = NULL;
1716                         try
1717                         {
1718                                 //JMutexAutoLock envlock(m_env_mutex);
1719                                 block = m_env.getMap().getBlockNoCreate(p);
1720                         }
1721                         catch(InvalidPositionException &e)
1722                         {
1723                         }
1724
1725                         if(block == NULL)
1726                                 continue;
1727
1728                         if(block->getMeshExpired() == false)
1729                                 continue;
1730
1731                         block->updateMesh(daynight_ratio);
1732
1733                         counter++;
1734                         if(counter >= 5)
1735                                 return;
1736                 }
1737         }
1738 }*/
1739