src/game.cpp

   1 /*
   2 Minetest-c55
   3 Copyright (C) 2010-2011 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 "game.h"
  21 #include "common_irrlicht.h"
  22 #include <IGUICheckBox.h>
  23 #include <IGUIEditBox.h>
  24 #include <IGUIButton.h>
  25 #include <IGUIStaticText.h>
  26 #include <IGUIFont.h>
  27 #include "client.h"
  28 #include "server.h"
  29 #include "guiPauseMenu.h"
  30 #include "guiPasswordChange.h"
  31 #include "guiInventoryMenu.h"
  32 #include "guiTextInputMenu.h"
  33 #include "guiDeathScreen.h"
  34 #include "tool.h"
  35 #include "guiChatConsole.h"
  36 #include "config.h"
  37 #include "clouds.h"
  38 #include "camera.h"
  39 #include "farmesh.h"
  40 #include "mapblock.h"
  41 #include "settings.h"
  42 #include "profiler.h"
  43 #include "mainmenumanager.h"
  44 #include "gettext.h"
  45 #include "log.h"
  46 #include "filesys.h"
  47 // Needed for determining pointing to nodes
  48 #include "nodedef.h"
  49 #include "nodemetadata.h"
  50 #include "main.h" // For g_settings
  51 #include "itemdef.h"
  52 #include "tile.h" // For TextureSource
  53 #include "logoutputbuffer.h"
  54
  55 /*
  56         Setting this to 1 enables a special camera mode that forces
  57         the renderers to think that the camera statically points from
  58         the starting place to a static direction.
  59
  60         This allows one to move around with the player and see what
  61         is actually drawn behind solid things and behind the player.
  62 */
  63 #define FIELD_OF_VIEW_TEST 0
  64
  65
  66 /*
  67         Text input system
  68 */
  69
  70 struct TextDestChat : public TextDest
  71 {
  72         TextDestChat(Client *client)
  73         {
  74                 m_client = client;
  75         }
  76         void gotText(std::wstring text)
  77         {
  78                 m_client->typeChatMessage(text);
  79         }
  80
  81         Client *m_client;
  82 };
  83
  84 struct TextDestNodeMetadata : public TextDest
  85 {
  86         TextDestNodeMetadata(v3s16 p, Client *client)
  87         {
  88                 m_p = p;
  89                 m_client = client;
  90         }
  91         void gotText(std::wstring text)
  92         {
  93                 std::string ntext = wide_to_narrow(text);
  94                 infostream<<"Changing text of a sign node: "
  95                                 <<ntext<<std::endl;
  96                 m_client->sendSignNodeText(m_p, ntext);
  97         }
  98
  99         v3s16 m_p;
 100         Client *m_client;
 101 };
 102
 103 /* Respawn menu callback */
 104
 105 class MainRespawnInitiator: public IRespawnInitiator
 106 {
 107 public:
 108         MainRespawnInitiator(bool *active, Client *client):
 109                 m_active(active), m_client(client)
 110         {
 111                 *m_active = true;
 112         }
 113         void respawn()
 114         {
 115                 *m_active = false;
 116                 m_client->sendRespawn();
 117         }
 118 private:
 119         bool *m_active;
 120         Client *m_client;
 121 };
 122
 123 /*
 124         Hotbar draw routine
 125 */
 126 void draw_hotbar(video::IVideoDriver *driver, gui::IGUIFont *font,
 127                 IGameDef *gamedef,
 128                 v2s32 centerlowerpos, s32 imgsize, s32 itemcount,
 129                 Inventory *inventory, s32 halfheartcount, u16 playeritem)
 130 {
 131         InventoryList *mainlist = inventory->getList("main");
 132         if(mainlist == NULL)
 133         {
 134                 errorstream<<"draw_hotbar(): mainlist == NULL"<<std::endl;
 135                 return;
 136         }
 137
 138         s32 padding = imgsize/12;
 139         //s32 height = imgsize + padding*2;
 140         s32 width = itemcount*(imgsize+padding*2);
 141
 142         // Position of upper left corner of bar
 143         v2s32 pos = centerlowerpos - v2s32(width/2, imgsize+padding*2);
 144
 145         // Draw background color
 146         /*core::rect<s32> barrect(0,0,width,height);
 147         barrect += pos;
 148         video::SColor bgcolor(255,128,128,128);
 149         driver->draw2DRectangle(bgcolor, barrect, NULL);*/
 150
 151         core::rect<s32> imgrect(0,0,imgsize,imgsize);
 152
 153         for(s32 i=0; i<itemcount; i++)
 154         {
 155                 const ItemStack &item = mainlist->getItem(i);
 156
 157                 core::rect<s32> rect = imgrect + pos
 158                                 + v2s32(padding+i*(imgsize+padding*2), padding);
 159
 160                 if(playeritem == i)
 161                 {
 162                         video::SColor c_outside(255,255,0,0);
 163                         //video::SColor c_outside(255,0,0,0);
 164                         //video::SColor c_inside(255,192,192,192);
 165                         s32 x1 = rect.UpperLeftCorner.X;
 166                         s32 y1 = rect.UpperLeftCorner.Y;
 167                         s32 x2 = rect.LowerRightCorner.X;
 168                         s32 y2 = rect.LowerRightCorner.Y;
 169                         // Black base borders
 170                         driver->draw2DRectangle(c_outside,
 171                                         core::rect<s32>(
 172                                                 v2s32(x1 - padding, y1 - padding),
 173                                                 v2s32(x2 + padding, y1)
 174                                         ), NULL);
 175                         driver->draw2DRectangle(c_outside,
 176                                         core::rect<s32>(
 177                                                 v2s32(x1 - padding, y2),
 178                                                 v2s32(x2 + padding, y2 + padding)
 179                                         ), NULL);
 180                         driver->draw2DRectangle(c_outside,
 181                                         core::rect<s32>(
 182                                                 v2s32(x1 - padding, y1),
 183                                                 v2s32(x1, y2)
 184                                         ), NULL);
 185                         driver->draw2DRectangle(c_outside,
 186                                         core::rect<s32>(
 187                                                 v2s32(x2, y1),
 188                                                 v2s32(x2 + padding, y2)
 189                                         ), NULL);
 190                         /*// Light inside borders
 191                         driver->draw2DRectangle(c_inside,
 192                                         core::rect<s32>(
 193                                                 v2s32(x1 - padding/2, y1 - padding/2),
 194                                                 v2s32(x2 + padding/2, y1)
 195                                         ), NULL);
 196                         driver->draw2DRectangle(c_inside,
 197                                         core::rect<s32>(
 198                                                 v2s32(x1 - padding/2, y2),
 199                                                 v2s32(x2 + padding/2, y2 + padding/2)
 200                                         ), NULL);
 201                         driver->draw2DRectangle(c_inside,
 202                                         core::rect<s32>(
 203                                                 v2s32(x1 - padding/2, y1),
 204                                                 v2s32(x1, y2)
 205                                         ), NULL);
 206                         driver->draw2DRectangle(c_inside,
 207                                         core::rect<s32>(
 208                                                 v2s32(x2, y1),
 209                                                 v2s32(x2 + padding/2, y2)
 210                                         ), NULL);
 211                         */
 212                 }
 213
 214                 video::SColor bgcolor2(128,0,0,0);
 215                 driver->draw2DRectangle(bgcolor2, rect, NULL);
 216                 drawItemStack(driver, font, item, rect, NULL, gamedef);
 217         }
 218
 219         /*
 220                 Draw hearts
 221         */
 222         video::ITexture *heart_texture =
 223                 gamedef->getTextureSource()->getTextureRaw("heart.png");
 224         if(heart_texture)
 225         {
 226                 v2s32 p = pos + v2s32(0, -20);
 227                 for(s32 i=0; i<halfheartcount/2; i++)
 228                 {
 229                         const video::SColor color(255,255,255,255);
 230                         const video::SColor colors[] = {color,color,color,color};
 231                         core::rect<s32> rect(0,0,16,16);
 232                         rect += p;
 233                         driver->draw2DImage(heart_texture, rect,
 234                                 core::rect<s32>(core::position2d<s32>(0,0),
 235                                 core::dimension2di(heart_texture->getOriginalSize())),
 236                                 NULL, colors, true);
 237                         p += v2s32(16,0);
 238                 }
 239                 if(halfheartcount % 2 == 1)
 240                 {
 241                         const video::SColor color(255,255,255,255);
 242                         const video::SColor colors[] = {color,color,color,color};
 243                         core::rect<s32> rect(0,0,16/2,16);
 244                         rect += p;
 245                         core::dimension2di srcd(heart_texture->getOriginalSize());
 246                         srcd.Width /= 2;
 247                         driver->draw2DImage(heart_texture, rect,
 248                                 core::rect<s32>(core::position2d<s32>(0,0), srcd),
 249                                 NULL, colors, true);
 250                         p += v2s32(16,0);
 251                 }
 252         }
 253 }
 254
 255 /*
 256         Check if a node is pointable
 257 */
 258 inline bool isPointableNode(const MapNode& n,
 259                 Client *client, bool liquids_pointable)
 260 {
 261         const ContentFeatures &features = client->getNodeDefManager()->get(n);
 262         return features.pointable ||
 263                 (liquids_pointable && features.isLiquid());
 264 }
 265
 266 /*
 267         Find what the player is pointing at
 268 */
 269 PointedThing getPointedThing(Client *client, v3f player_position,
 270                 v3f camera_direction, v3f camera_position,
 271                 core::line3d<f32> shootline, f32 d,
 272                 bool liquids_pointable,
 273                 bool look_for_object,
 274                 core::aabbox3d<f32> &hilightbox,
 275                 bool &should_show_hilightbox,
 276                 ClientActiveObject *&selected_object)
 277 {
 278         PointedThing result;
 279
 280         hilightbox = core::aabbox3d<f32>(0,0,0,0,0,0);
 281         should_show_hilightbox = false;
 282         selected_object = NULL;
 283
 284         INodeDefManager *nodedef = client->getNodeDefManager();
 285
 286         // First try to find a pointed at active object
 287         if(look_for_object)
 288         {
 289                 selected_object = client->getSelectedActiveObject(d*BS,
 290                                 camera_position, shootline);
 291         }
 292         if(selected_object != NULL)
 293         {
 294                 core::aabbox3d<f32> *selection_box
 295                         = selected_object->getSelectionBox();
 296                 // Box should exist because object was returned in the
 297                 // first place
 298                 assert(selection_box);
 299
 300                 v3f pos = selected_object->getPosition();
 301
 302                 hilightbox = core::aabbox3d<f32>(
 303                                 selection_box->MinEdge + pos,
 304                                 selection_box->MaxEdge + pos
 305                 );
 306
 307                 should_show_hilightbox = selected_object->doShowSelectionBox();
 308
 309                 result.type = POINTEDTHING_OBJECT;
 310                 result.object_id = selected_object->getId();
 311                 return result;
 312         }
 313
 314         // That didn't work, try to find a pointed at node
 315
 316         f32 mindistance = BS * 1001;
 317
 318         v3s16 pos_i = floatToInt(player_position, BS);
 319
 320         /*infostream<<"pos_i=("<<pos_i.X<<","<<pos_i.Y<<","<<pos_i.Z<<")"
 321                         <<std::endl;*/
 322
 323         s16 a = d;
 324         s16 ystart = pos_i.Y + 0 - (camera_direction.Y<0 ? a : 1);
 325         s16 zstart = pos_i.Z - (camera_direction.Z<0 ? a : 1);
 326         s16 xstart = pos_i.X - (camera_direction.X<0 ? a : 1);
 327         s16 yend = pos_i.Y + 1 + (camera_direction.Y>0 ? a : 1);
 328         s16 zend = pos_i.Z + (camera_direction.Z>0 ? a : 1);
 329         s16 xend = pos_i.X + (camera_direction.X>0 ? a : 1);
 330
 331         for(s16 y = ystart; y <= yend; y++)
 332         for(s16 z = zstart; z <= zend; z++)
 333         for(s16 x = xstart; x <= xend; x++)
 334         {
 335                 MapNode n;
 336                 try
 337                 {
 338                         n = client->getNode(v3s16(x,y,z));
 339                 }
 340                 catch(InvalidPositionException &e)
 341                 {
 342                         continue;
 343                 }
 344                 if(!isPointableNode(n, client, liquids_pointable))
 345                         continue;
 346
 347                 v3s16 np(x,y,z);
 348                 v3f npf = intToFloat(np, BS);
 349
 350                 f32 d = 0.01;
 351
 352                 v3s16 dirs[6] = {
 353                         v3s16(0,0,1), // back
 354                         v3s16(0,1,0), // top
 355                         v3s16(1,0,0), // right
 356                         v3s16(0,0,-1), // front
 357                         v3s16(0,-1,0), // bottom
 358                         v3s16(-1,0,0), // left
 359                 };
 360
 361                 const ContentFeatures &f = nodedef->get(n);
 362
 363                 if(f.selection_box.type == NODEBOX_FIXED)
 364                 {
 365                         core::aabbox3d<f32> box = f.selection_box.fixed;
 366                         box.MinEdge += npf;
 367                         box.MaxEdge += npf;
 368
 369                         v3s16 facedirs[6] = {
 370                                 v3s16(-1,0,0),
 371                                 v3s16(1,0,0),
 372                                 v3s16(0,-1,0),
 373                                 v3s16(0,1,0),
 374                                 v3s16(0,0,-1),
 375                                 v3s16(0,0,1),
 376                         };
 377
 378                         core::aabbox3d<f32> faceboxes[6] = {
 379                                 // X-
 380                                 core::aabbox3d<f32>(
 381                                         box.MinEdge.X, box.MinEdge.Y, box.MinEdge.Z,
 382                                         box.MinEdge.X+d, box.MaxEdge.Y, box.MaxEdge.Z
 383                                 ),
 384                                 // X+
 385                                 core::aabbox3d<f32>(
 386                                         box.MaxEdge.X-d, box.MinEdge.Y, box.MinEdge.Z,
 387                                         box.MaxEdge.X, box.MaxEdge.Y, box.MaxEdge.Z
 388                                 ),
 389                                 // Y-
 390                                 core::aabbox3d<f32>(
 391                                         box.MinEdge.X, box.MinEdge.Y, box.MinEdge.Z,
 392                                         box.MaxEdge.X, box.MinEdge.Y+d, box.MaxEdge.Z
 393                                 ),
 394                                 // Y+
 395                                 core::aabbox3d<f32>(
 396                                         box.MinEdge.X, box.MaxEdge.Y-d, box.MinEdge.Z,
 397                                         box.MaxEdge.X, box.MaxEdge.Y, box.MaxEdge.Z
 398                                 ),
 399                                 // Z-
 400                                 core::aabbox3d<f32>(
 401                                         box.MinEdge.X, box.MinEdge.Y, box.MinEdge.Z,
 402                                         box.MaxEdge.X, box.MaxEdge.Y, box.MinEdge.Z+d
 403                                 ),
 404                                 // Z+
 405                                 core::aabbox3d<f32>(
 406                                         box.MinEdge.X, box.MinEdge.Y, box.MaxEdge.Z-d,
 407                                         box.MaxEdge.X, box.MaxEdge.Y, box.MaxEdge.Z
 408                                 ),
 409                         };
 410
 411                         for(u16 i=0; i<6; i++)
 412                         {
 413                                 v3f facedir_f(facedirs[i].X, facedirs[i].Y, facedirs[i].Z);
 414                                 v3f centerpoint = npf + facedir_f * BS/2;
 415                                 f32 distance = (centerpoint - camera_position).getLength();
 416                                 if(distance >= mindistance)
 417                                         continue;
 418                                 if(!faceboxes[i].intersectsWithLine(shootline))
 419                                         continue;
 420                                 result.type = POINTEDTHING_NODE;
 421                                 result.node_undersurface = np;
 422                                 result.node_abovesurface = np+facedirs[i];
 423                                 mindistance = distance;
 424                                 hilightbox = box;
 425                                 should_show_hilightbox = true;
 426                         }
 427                 }
 428                 else if(f.selection_box.type == NODEBOX_WALLMOUNTED)
 429                 {
 430                         v3s16 dir = n.getWallMountedDir(nodedef);
 431                         v3f dir_f = v3f(dir.X, dir.Y, dir.Z);
 432                         dir_f *= BS/2 - BS/6 - BS/20;
 433                         v3f cpf = npf + dir_f;
 434                         f32 distance = (cpf - camera_position).getLength();
 435
 436                         core::aabbox3d<f32> box;
 437
 438                         // top
 439                         if(dir == v3s16(0,1,0)){
 440                                 box = f.selection_box.wall_top;
 441                         }
 442                         // bottom
 443                         else if(dir == v3s16(0,-1,0)){
 444                                 box = f.selection_box.wall_bottom;
 445                         }
 446                         // side
 447                         else{
 448                                 v3f vertices[2] =
 449                                 {
 450                                         f.selection_box.wall_side.MinEdge,
 451                                         f.selection_box.wall_side.MaxEdge
 452                                 };
 453
 454                                 for(s32 i=0; i<2; i++)
 455                                 {
 456                                         if(dir == v3s16(-1,0,0))
 457                                                 vertices[i].rotateXZBy(0);
 458                                         if(dir == v3s16(1,0,0))
 459                                                 vertices[i].rotateXZBy(180);
 460                                         if(dir == v3s16(0,0,-1))
 461                                                 vertices[i].rotateXZBy(90);
 462                                         if(dir == v3s16(0,0,1))
 463                                                 vertices[i].rotateXZBy(-90);
 464                                 }
 465
 466                                 box = core::aabbox3d<f32>(vertices[0]);
 467                                 box.addInternalPoint(vertices[1]);
 468                         }
 469
 470                         box.MinEdge += npf;
 471                         box.MaxEdge += npf;
 472
 473                         if(distance < mindistance)
 474                         {
 475                                 if(box.intersectsWithLine(shootline))
 476                                 {
 477                                         result.type = POINTEDTHING_NODE;
 478                                         result.node_undersurface = np;
 479                                         result.node_abovesurface = np;
 480                                         mindistance = distance;
 481                                         hilightbox = box;
 482                                         should_show_hilightbox = true;
 483                                 }
 484                         }
 485                 }
 486                 else // NODEBOX_REGULAR
 487                 {
 488                         for(u16 i=0; i<6; i++)
 489                         {
 490                                 v3f dir_f = v3f(dirs[i].X,
 491                                                 dirs[i].Y, dirs[i].Z);
 492                                 v3f centerpoint = npf + dir_f * BS/2;
 493                                 f32 distance =
 494                                                 (centerpoint - camera_position).getLength();
 495
 496                                 if(distance < mindistance)
 497                                 {
 498                                         core::CMatrix4<f32> m;
 499                                         m.buildRotateFromTo(v3f(0,0,1), dir_f);
 500
 501                                         // This is the back face
 502                                         v3f corners[2] = {
 503                                                 v3f(BS/2, BS/2, BS/2),
 504                                                 v3f(-BS/2, -BS/2, BS/2+d)
 505                                         };
 506
 507                                         for(u16 j=0; j<2; j++)
 508                                         {
 509                                                 m.rotateVect(corners[j]);
 510                                                 corners[j] += npf;
 511                                         }
 512
 513                                         core::aabbox3d<f32> facebox(corners[0]);
 514                                         facebox.addInternalPoint(corners[1]);
 515
 516                                         if(facebox.intersectsWithLine(shootline))
 517                                         {
 518                                                 result.type = POINTEDTHING_NODE;
 519                                                 result.node_undersurface = np;
 520                                                 result.node_abovesurface = np + dirs[i];
 521                                                 mindistance = distance;
 522
 523                                                 //hilightbox = facebox;
 524
 525                                                 const float d = 0.502;
 526                                                 core::aabbox3d<f32> nodebox
 527                                                                 (-BS*d, -BS*d, -BS*d, BS*d, BS*d, BS*d);
 528                                                 v3f nodepos_f = intToFloat(np, BS);
 529                                                 nodebox.MinEdge += nodepos_f;
 530                                                 nodebox.MaxEdge += nodepos_f;
 531                                                 hilightbox = nodebox;
 532                                                 should_show_hilightbox = true;
 533                                         }
 534                                 } // if distance < mindistance
 535                         } // for dirs
 536                 } // regular block
 537         } // for coords
 538
 539         return result;
 540 }
 541
 542 void update_skybox(video::IVideoDriver* driver, ITextureSource *tsrc,
 543                 scene::ISceneManager* smgr, scene::ISceneNode* &skybox,
 544                 float brightness)
 545 {
 546         if(skybox)
 547         {
 548                 skybox->remove();
 549         }
 550
 551         /*// Disable skybox if FarMesh is enabled
 552         if(g_settings->getBool("enable_farmesh"))
 553                 return;*/
 554
 555         if(brightness >= 0.7)
 556         {
 557                 skybox = smgr->addSkyBoxSceneNode(
 558                         tsrc->getTextureRaw("skybox2.png"),
 559                         tsrc->getTextureRaw("skybox3.png"),
 560                         tsrc->getTextureRaw("skybox1.png"),
 561                         tsrc->getTextureRaw("skybox1.png"),
 562                         tsrc->getTextureRaw("skybox1.png"),
 563                         tsrc->getTextureRaw("skybox1.png"));
 564         }
 565         else if(brightness >= 0.2)
 566         {
 567                 skybox = smgr->addSkyBoxSceneNode(
 568                         tsrc->getTextureRaw("skybox2_dawn.png"),
 569                         tsrc->getTextureRaw("skybox3_dawn.png"),
 570                         tsrc->getTextureRaw("skybox1_dawn.png"),
 571                         tsrc->getTextureRaw("skybox1_dawn.png"),
 572                         tsrc->getTextureRaw("skybox1_dawn.png"),
 573                         tsrc->getTextureRaw("skybox1_dawn.png"));
 574         }
 575         else
 576         {
 577                 skybox = smgr->addSkyBoxSceneNode(
 578                         tsrc->getTextureRaw("skybox2_night.png"),
 579                         tsrc->getTextureRaw("skybox3_night.png"),
 580                         tsrc->getTextureRaw("skybox1_night.png"),
 581                         tsrc->getTextureRaw("skybox1_night.png"),
 582                         tsrc->getTextureRaw("skybox1_night.png"),
 583                         tsrc->getTextureRaw("skybox1_night.png"));
 584         }
 585 }
 586
 587 /*
 588         Draws a screen with a single text on it.
 589         Text will be removed when the screen is drawn the next time.
 590 */
 591 /*gui::IGUIStaticText **/
 592 void draw_load_screen(const std::wstring &text,
 593                 video::IVideoDriver* driver, gui::IGUIFont* font)
 594 {
 595         v2u32 screensize = driver->getScreenSize();
 596         const wchar_t *loadingtext = text.c_str();
 597         core::vector2d<u32> textsize_u = font->getDimension(loadingtext);
 598         core::vector2d<s32> textsize(textsize_u.X,textsize_u.Y);
 599         core::vector2d<s32> center(screensize.X/2, screensize.Y/2);
 600         core::rect<s32> textrect(center - textsize/2, center + textsize/2);
 601
 602         gui::IGUIStaticText *guitext = guienv->addStaticText(
 603                         loadingtext, textrect, false, false);
 604         guitext->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 605
 606         driver->beginScene(true, true, video::SColor(255,0,0,0));
 607         guienv->drawAll();
 608         driver->endScene();
 609
 610         guitext->remove();
 611
 612         //return guitext;
 613 }
 614
 615 /* Profiler display */
 616
 617 void update_profiler_gui(gui::IGUIStaticText *guitext_profiler,
 618                 gui::IGUIFont *font, u32 text_height,
 619                 u32 show_profiler, u32 show_profiler_max)
 620 {
 621         if(show_profiler == 0)
 622         {
 623                 guitext_profiler->setVisible(false);
 624         }
 625         else
 626         {
 627
 628                 std::ostringstream os(std::ios_base::binary);
 629                 g_profiler->printPage(os, show_profiler, show_profiler_max);
 630                 std::wstring text = narrow_to_wide(os.str());
 631                 guitext_profiler->setText(text.c_str());
 632                 guitext_profiler->setVisible(true);
 633
 634                 s32 w = font->getDimension(text.c_str()).Width;
 635                 if(w < 400)
 636                         w = 400;
 637                 core::rect<s32> rect(6, 4+(text_height+5)*2, 12+w,
 638                                 8+(text_height+5)*2 +
 639                                 font->getDimension(text.c_str()).Height);
 640                 guitext_profiler->setRelativePosition(rect);
 641                 guitext_profiler->setVisible(true);
 642         }
 643 }
 644
 645 void the_game(
 646         bool &kill,
 647         bool random_input,
 648         InputHandler *input,
 649         IrrlichtDevice *device,
 650         gui::IGUIFont* font,
 651         std::string map_dir,
 652         std::string playername,
 653         std::string password,
 654         std::string address,
 655         u16 port,
 656         std::wstring &error_message,
 657         std::string configpath,
 658         ChatBackend &chat_backend
 659 )
 660 {
 661         video::IVideoDriver* driver = device->getVideoDriver();
 662         scene::ISceneManager* smgr = device->getSceneManager();
 663
 664         // Calculate text height using the font
 665         u32 text_height = font->getDimension(L"Random test string").Height;
 666
 667         v2u32 screensize(0,0);
 668         v2u32 last_screensize(0,0);
 669         screensize = driver->getScreenSize();
 670
 671         const s32 hotbar_itemcount = 8;
 672         //const s32 hotbar_imagesize = 36;
 673         //const s32 hotbar_imagesize = 64;
 674         s32 hotbar_imagesize = 48;
 675
 676         // The color of the sky
 677
 678         //video::SColor skycolor = video::SColor(255,140,186,250);
 679
 680         video::SColor bgcolor_bright = video::SColor(255,170,200,230);
 681
 682         /*
 683                 Draw "Loading" screen
 684         */
 685
 686         draw_load_screen(L"Loading...", driver, font);
 687
 688         // Create texture source
 689         IWritableTextureSource *tsrc = createTextureSource(device);
 690
 691         // These will be filled by data received from the server
 692         // Create item definition manager
 693         IWritableItemDefManager *itemdef = createItemDefManager();
 694         // Create node definition manager
 695         IWritableNodeDefManager *nodedef = createNodeDefManager();
 696
 697         // Add chat log output for errors to be shown in chat
 698         LogOutputBuffer chat_log_error_buf(LMT_ERROR);
 699
 700         /*
 701                 Create server.
 702                 SharedPtr will delete it when it goes out of scope.
 703         */
 704         SharedPtr<Server> server;
 705         if(address == ""){
 706                 draw_load_screen(L"Creating server...", driver, font);
 707                 infostream<<"Creating server"<<std::endl;
 708                 server = new Server(map_dir, configpath, "mesetint");
 709                 server->start(port);
 710         }
 711
 712         do{ // Client scope (breakable do-while(0))
 713
 714         /*
 715                 Create client
 716         */
 717
 718         draw_load_screen(L"Creating client...", driver, font);
 719         infostream<<"Creating client"<<std::endl;
 720
 721         MapDrawControl draw_control;
 722
 723         Client client(device, playername.c_str(), password, draw_control,
 724                         tsrc, itemdef, nodedef);
 725
 726         // Client acts as our GameDef
 727         IGameDef *gamedef = &client;
 728
 729         draw_load_screen(L"Resolving address...", driver, font);
 730         Address connect_address(0,0,0,0, port);
 731         try{
 732                 if(address == "")
 733                         //connect_address.Resolve("localhost");
 734                         connect_address.setAddress(127,0,0,1);
 735                 else
 736                         connect_address.Resolve(address.c_str());
 737         }
 738         catch(ResolveError &e)
 739         {
 740                 error_message = L"Couldn't resolve address";
 741                 errorstream<<wide_to_narrow(error_message)<<std::endl;
 742                 // Break out of client scope
 743                 break;
 744         }
 745
 746         /*
 747                 Attempt to connect to the server
 748         */
 749
 750         infostream<<"Connecting to server at ";
 751         connect_address.print(&infostream);
 752         infostream<<std::endl;
 753         client.connect(connect_address);
 754
 755         /*
 756                 Wait for server to accept connection
 757         */
 758         bool could_connect = false;
 759         bool connect_aborted = false;
 760         try{
 761                 float frametime = 0.033;
 762                 float time_counter = 0.0;
 763                 input->clear();
 764                 while(device->run())
 765                 {
 766                         // Update client and server
 767                         client.step(frametime);
 768                         if(server != NULL)
 769                                 server->step(frametime);
 770
 771                         // End condition
 772                         if(client.connectedAndInitialized()){
 773                                 could_connect = true;
 774                                 break;
 775                         }
 776                         // Break conditions
 777                         if(client.accessDenied()){
 778                                 error_message = L"Access denied. Reason: "
 779                                                 +client.accessDeniedReason();
 780                                 errorstream<<wide_to_narrow(error_message)<<std::endl;
 781                                 break;
 782                         }
 783                         if(input->wasKeyDown(EscapeKey)){
 784                                 connect_aborted = true;
 785                                 infostream<<"Connect aborted [Escape]"<<std::endl;
 786                                 break;
 787                         }
 788
 789                         // Display status
 790                         std::wostringstream ss;
 791                         ss<<L"Connecting to server... (press Escape to cancel)\n";
 792                         std::wstring animation = L"/-\\|";
 793                         ss<<animation[(int)(time_counter/0.2)%4];
 794                         draw_load_screen(ss.str(), driver, font);
 795
 796                         // Delay a bit
 797                         sleep_ms(1000*frametime);
 798                         time_counter += frametime;
 799                 }
 800         }
 801         catch(con::PeerNotFoundException &e)
 802         {}
 803
 804         /*
 805                 Handle failure to connect
 806         */
 807         if(!could_connect){
 808                 if(error_message == L"" && !connect_aborted){
 809                         error_message = L"Connection failed";
 810                         errorstream<<wide_to_narrow(error_message)<<std::endl;
 811                 }
 812                 // Break out of client scope
 813                 break;
 814         }
 815
 816         /*
 817                 Wait until content has been received
 818         */
 819         bool got_content = false;
 820         bool content_aborted = false;
 821         {
 822                 float frametime = 0.033;
 823                 float time_counter = 0.0;
 824                 input->clear();
 825                 while(device->run())
 826                 {
 827                         // Update client and server
 828                         client.step(frametime);
 829                         if(server != NULL)
 830                                 server->step(frametime);
 831
 832                         // End condition
 833                         if(client.texturesReceived() &&
 834                                         client.itemdefReceived() &&
 835                                         client.nodedefReceived()){
 836                                 got_content = true;
 837                                 break;
 838                         }
 839                         // Break conditions
 840                         if(!client.connectedAndInitialized()){
 841                                 error_message = L"Client disconnected";
 842                                 errorstream<<wide_to_narrow(error_message)<<std::endl;
 843                                 break;
 844                         }
 845                         if(input->wasKeyDown(EscapeKey)){
 846                                 content_aborted = true;
 847                                 infostream<<"Connect aborted [Escape]"<<std::endl;
 848                                 break;
 849                         }
 850
 851                         // Display status
 852                         std::wostringstream ss;
 853                         ss<<L"Waiting content... (press Escape to cancel)\n";
 854
 855                         ss<<(client.itemdefReceived()?L"[X]":L"[  ]");
 856                         ss<<L" Item definitions\n";
 857                         ss<<(client.nodedefReceived()?L"[X]":L"[  ]");
 858                         ss<<L" Node definitions\n";
 859                         //ss<<(client.texturesReceived()?L"[X]":L"[  ]");
 860                         ss<<L"["<<(int)(client.textureReceiveProgress()*100+0.5)<<L"%] ";
 861                         ss<<L" Textures\n";
 862
 863                         draw_load_screen(ss.str(), driver, font);
 864
 865                         // Delay a bit
 866                         sleep_ms(1000*frametime);
 867                         time_counter += frametime;
 868                 }
 869         }
 870
 871         if(!got_content){
 872                 if(error_message == L"" && !content_aborted){
 873                         error_message = L"Something failed";
 874                         errorstream<<wide_to_narrow(error_message)<<std::endl;
 875                 }
 876                 // Break out of client scope
 877                 break;
 878         }
 879
 880         /*
 881                 After all content has been received:
 882                 Update cached textures, meshes and materials
 883         */
 884         client.afterContentReceived();
 885
 886         /*
 887                 Create skybox
 888         */
 889         float old_brightness = 1.0;
 890         scene::ISceneNode* skybox = NULL;
 891         update_skybox(driver, tsrc, smgr, skybox, 1.0);
 892
 893         /*
 894                 Create the camera node
 895         */
 896         Camera camera(smgr, draw_control);
 897         if (!camera.successfullyCreated(error_message))
 898                 return;
 899
 900         f32 camera_yaw = 0; // "right/left"
 901         f32 camera_pitch = 0; // "up/down"
 902
 903         /*
 904                 Clouds
 905         */
 906
 907         float cloud_height = BS*100;
 908         Clouds *clouds = NULL;
 909         if(g_settings->getBool("enable_clouds"))
 910         {
 911                 clouds = new Clouds(smgr->getRootSceneNode(), smgr, -1,
 912                                 cloud_height, time(0));
 913         }
 914
 915         /*
 916                 FarMesh
 917         */
 918
 919         FarMesh *farmesh = NULL;
 920         if(g_settings->getBool("enable_farmesh"))
 921         {
 922                 farmesh = new FarMesh(smgr->getRootSceneNode(), smgr, -1, client.getMapSeed(), &client);
 923         }
 924
 925         /*
 926                 A copy of the local inventory
 927         */
 928         Inventory local_inventory(itemdef);
 929
 930         /*
 931                 Move into game
 932         */
 933
 934         //gui_loadingtext->remove();
 935
 936         /*
 937                 Add some gui stuff
 938         */
 939
 940         // First line of debug text
 941         gui::IGUIStaticText *guitext = guienv->addStaticText(
 942                         L"Minetest-c55",
 943                         core::rect<s32>(5, 5, 795, 5+text_height),
 944                         false, false);
 945         // Second line of debug text
 946         gui::IGUIStaticText *guitext2 = guienv->addStaticText(
 947                         L"",
 948                         core::rect<s32>(5, 5+(text_height+5)*1, 795, (5+text_height)*2),
 949                         false, false);
 950         // At the middle of the screen
 951         // Object infos are shown in this
 952         gui::IGUIStaticText *guitext_info = guienv->addStaticText(
 953                         L"",
 954                         core::rect<s32>(0,0,400,text_height*5+5) + v2s32(100,200),
 955                         false, false);
 956
 957         // Status text (displays info when showing and hiding GUI stuff, etc.)
 958         gui::IGUIStaticText *guitext_status = guienv->addStaticText(
 959                         L"<Status>",
 960                         core::rect<s32>(0,0,0,0),
 961                         false, false);
 962         guitext_status->setVisible(false);
 963
 964         std::wstring statustext;
 965         float statustext_time = 0;
 966
 967         // Chat text
 968         gui::IGUIStaticText *guitext_chat = guienv->addStaticText(
 969                         L"",
 970                         core::rect<s32>(0,0,0,0),
 971                         //false, false); // Disable word wrap as of now
 972                         false, true);
 973         // Remove stale "recent" chat messages from previous connections
 974         chat_backend.clearRecentChat();
 975         // Chat backend and console
 976         GUIChatConsole *gui_chat_console = new GUIChatConsole(guienv, guienv->getRootGUIElement(), -1, &chat_backend, &client);
 977
 978         // Profiler text (size is updated when text is updated)
 979         gui::IGUIStaticText *guitext_profiler = guienv->addStaticText(
 980                         L"<Profiler>",
 981                         core::rect<s32>(0,0,0,0),
 982                         false, false);
 983         guitext_profiler->setBackgroundColor(video::SColor(80,0,0,0));
 984         guitext_profiler->setVisible(false);
 985
 986         /*GUIQuickInventory *quick_inventory = new GUIQuickInventory
 987                         (guienv, NULL, v2s32(10, 70), 5, &local_inventory);*/
 988         /*GUIQuickInventory *quick_inventory = new GUIQuickInventory
 989                         (guienv, NULL, v2s32(0, 0), quickinv_itemcount, &local_inventory);*/
 990
 991         // Test the text input system
 992         /*(new GUITextInputMenu(guienv, guiroot, -1, &g_menumgr,
 993                         NULL))->drop();*/
 994         /*GUIMessageMenu *menu =
 995                         new GUIMessageMenu(guienv, guiroot, -1,
 996                                 &g_menumgr,
 997                                 L"Asd");
 998         menu->drop();*/
 999
1000         // Launch pause menu
1001         /*(new GUIPauseMenu(guienv, guiroot, -1, g_gamecallback,
1002                         &g_menumgr))->drop();*/
1003
1004         //s32 guitext_chat_pad_bottom = 70;
1005
1006         /*
1007                 Some statistics are collected in these
1008         */
1009         u32 drawtime = 0;
1010         u32 beginscenetime = 0;
1011         u32 scenetime = 0;
1012         u32 endscenetime = 0;
1013
1014         // A test
1015         //throw con::PeerNotFoundException("lol");
1016
1017         float brightness = 1.0;
1018
1019         core::list<float> frametime_log;
1020
1021         float nodig_delay_timer = 0.0;
1022         float dig_time = 0.0;
1023         u16 dig_index = 0;
1024         PointedThing pointed_old;
1025         bool digging = false;
1026         bool ldown_for_dig = false;
1027
1028         float damage_flash_timer = 0;
1029         s16 farmesh_range = 20*MAP_BLOCKSIZE;
1030
1031         const float object_hit_delay = 0.2;
1032         float object_hit_delay_timer = 0.0;
1033         float time_from_last_punch = 10;
1034
1035         bool invert_mouse = g_settings->getBool("invert_mouse");
1036
1037         bool respawn_menu_active = false;
1038         bool update_wielded_item_trigger = false;
1039
1040         bool show_hud = true;
1041         bool show_chat = true;
1042         bool force_fog_off = false;
1043         bool disable_camera_update = false;
1044         bool show_debug = g_settings->getBool("show_debug");
1045         bool show_debug_frametime = false;
1046         u32 show_profiler = 0;
1047         u32 show_profiler_max = 3;  // Number of pages
1048
1049         /*
1050                 Main loop
1051         */
1052
1053         bool first_loop_after_window_activation = true;
1054
1055         // TODO: Convert the static interval timers to these
1056         // Interval limiter for profiler
1057         IntervalLimiter m_profiler_interval;
1058
1059         // Time is in milliseconds
1060         // NOTE: getRealTime() causes strange problems in wine (imprecision?)
1061         // NOTE: So we have to use getTime() and call run()s between them
1062         u32 lasttime = device->getTimer()->getTime();
1063
1064         while(device->run() && kill == false)
1065         {
1066                 //std::cerr<<"frame"<<std::endl;
1067
1068                 if(client.accessDenied())
1069                 {
1070                         error_message = L"Access denied. Reason: "
1071                                         +client.accessDeniedReason();
1072                         errorstream<<wide_to_narrow(error_message)<<std::endl;
1073                         break;
1074                 }
1075
1076                 if(g_gamecallback->disconnect_requested)
1077                 {
1078                         g_gamecallback->disconnect_requested = false;
1079                         break;
1080                 }
1081
1082                 if(g_gamecallback->changepassword_requested)
1083                 {
1084                         (new GUIPasswordChange(guienv, guiroot, -1,
1085                                 &g_menumgr, &client))->drop();
1086                         g_gamecallback->changepassword_requested = false;
1087                 }
1088
1089                 /*
1090                         Process TextureSource's queue
1091                 */
1092                 tsrc->processQueue();
1093
1094                 /*
1095                         Random calculations
1096                 */
1097                 last_screensize = screensize;
1098                 screensize = driver->getScreenSize();
1099                 v2s32 displaycenter(screensize.X/2,screensize.Y/2);
1100                 //bool screensize_changed = screensize != last_screensize;
1101
1102                 // Resize hotbar
1103                 if(screensize.Y <= 800)
1104                         hotbar_imagesize = 32;
1105                 else if(screensize.Y <= 1280)
1106                         hotbar_imagesize = 48;
1107                 else
1108                         hotbar_imagesize = 64;
1109
1110                 // Hilight boxes collected during the loop and displayed
1111                 core::list< core::aabbox3d<f32> > hilightboxes;
1112
1113                 // Info text
1114                 std::wstring infotext;
1115
1116                 // When screen size changes, update positions and sizes of stuff
1117                 /*if(screensize_changed)
1118                 {
1119                         v2s32 pos(displaycenter.X-((quickinv_itemcount-1)*quickinv_spacing+quickinv_size)/2, screensize.Y-quickinv_spacing);
1120                         quick_inventory->updatePosition(pos);
1121                 }*/
1122
1123                 //TimeTaker //timer1("//timer1");
1124
1125                 // Time of frame without fps limit
1126                 float busytime;
1127                 u32 busytime_u32;
1128                 {
1129                         // not using getRealTime is necessary for wine
1130                         u32 time = device->getTimer()->getTime();
1131                         if(time > lasttime)
1132                                 busytime_u32 = time - lasttime;
1133                         else
1134                                 busytime_u32 = 0;
1135                         busytime = busytime_u32 / 1000.0;
1136                 }
1137
1138                 //infostream<<"busytime_u32="<<busytime_u32<<std::endl;
1139
1140                 // Necessary for device->getTimer()->getTime()
1141                 device->run();
1142
1143                 /*
1144                         FPS limiter
1145                 */
1146
1147                 {
1148                         float fps_max = g_settings->getFloat("fps_max");
1149                         u32 frametime_min = 1000./fps_max;
1150
1151                         if(busytime_u32 < frametime_min)
1152                         {
1153                                 u32 sleeptime = frametime_min - busytime_u32;
1154                                 device->sleep(sleeptime);
1155                         }
1156                 }
1157
1158                 // Necessary for device->getTimer()->getTime()
1159                 device->run();
1160
1161                 /*
1162                         Time difference calculation
1163                 */
1164                 f32 dtime; // in seconds
1165
1166                 u32 time = device->getTimer()->getTime();
1167                 if(time > lasttime)
1168                         dtime = (time - lasttime) / 1000.0;
1169                 else
1170                         dtime = 0;
1171                 lasttime = time;
1172
1173                 /* Run timers */
1174
1175                 if(nodig_delay_timer >= 0)
1176                         nodig_delay_timer -= dtime;
1177                 if(object_hit_delay_timer >= 0)
1178                         object_hit_delay_timer -= dtime;
1179                 time_from_last_punch += dtime;
1180
1181                 g_profiler->add("Elapsed time", dtime);
1182                 g_profiler->avg("FPS", 1./dtime);
1183
1184                 /*
1185                         Log frametime for visualization
1186                 */
1187                 frametime_log.push_back(dtime);
1188                 if(frametime_log.size() > 100)
1189                 {
1190                         core::list<float>::Iterator i = frametime_log.begin();
1191                         frametime_log.erase(i);
1192                 }
1193
1194                 /*
1195                         Visualize frametime in terminal
1196                 */
1197                 /*for(u32 i=0; i<dtime*400; i++)
1198                         infostream<<"X";
1199                 infostream<<std::endl;*/
1200
1201                 /*
1202                         Time average and jitter calculation
1203                 */
1204
1205                 static f32 dtime_avg1 = 0.0;
1206                 dtime_avg1 = dtime_avg1 * 0.96 + dtime * 0.04;
1207                 f32 dtime_jitter1 = dtime - dtime_avg1;
1208
1209                 static f32 dtime_jitter1_max_sample = 0.0;
1210                 static f32 dtime_jitter1_max_fraction = 0.0;
1211                 {
1212                         static f32 jitter1_max = 0.0;
1213                         static f32 counter = 0.0;
1214                         if(dtime_jitter1 > jitter1_max)
1215                                 jitter1_max = dtime_jitter1;
1216                         counter += dtime;
1217                         if(counter > 0.0)
1218                         {
1219                                 counter -= 3.0;
1220                                 dtime_jitter1_max_sample = jitter1_max;
1221                                 dtime_jitter1_max_fraction
1222                                                 = dtime_jitter1_max_sample / (dtime_avg1+0.001);
1223                                 jitter1_max = 0.0;
1224                         }
1225                 }
1226
1227                 /*
1228                         Busytime average and jitter calculation
1229                 */
1230
1231                 static f32 busytime_avg1 = 0.0;
1232                 busytime_avg1 = busytime_avg1 * 0.98 + busytime * 0.02;
1233                 f32 busytime_jitter1 = busytime - busytime_avg1;
1234
1235                 static f32 busytime_jitter1_max_sample = 0.0;
1236                 static f32 busytime_jitter1_min_sample = 0.0;
1237                 {
1238                         static f32 jitter1_max = 0.0;
1239                         static f32 jitter1_min = 0.0;
1240                         static f32 counter = 0.0;
1241                         if(busytime_jitter1 > jitter1_max)
1242                                 jitter1_max = busytime_jitter1;
1243                         if(busytime_jitter1 < jitter1_min)
1244                                 jitter1_min = busytime_jitter1;
1245                         counter += dtime;
1246                         if(counter > 0.0){
1247                                 counter -= 3.0;
1248                                 busytime_jitter1_max_sample = jitter1_max;
1249                                 busytime_jitter1_min_sample = jitter1_min;
1250                                 jitter1_max = 0.0;
1251                                 jitter1_min = 0.0;
1252                         }
1253                 }
1254
1255                 /*
1256                         Debug info for client
1257                 */
1258                 {
1259                         static float counter = 0.0;
1260                         counter -= dtime;
1261                         if(counter < 0)
1262                         {
1263                                 counter = 30.0;
1264                                 client.printDebugInfo(infostream);
1265                         }
1266                 }
1267
1268                 /*
1269                         Profiler
1270                 */
1271                 float profiler_print_interval =
1272                                 g_settings->getFloat("profiler_print_interval");
1273                 bool print_to_log = true;
1274                 if(profiler_print_interval == 0){
1275                         print_to_log = false;
1276                         profiler_print_interval = 5;
1277                 }
1278                 if(m_profiler_interval.step(dtime, profiler_print_interval))
1279                 {
1280                         if(print_to_log){
1281                                 infostream<<"Profiler:"<<std::endl;
1282                                 g_profiler->print(infostream);
1283                         }
1284
1285                         update_profiler_gui(guitext_profiler, font, text_height,
1286                                         show_profiler, show_profiler_max);
1287
1288                         g_profiler->clear();
1289                 }
1290
1291                 /*
1292                         Direct handling of user input
1293                 */
1294
1295                 // Reset input if window not active or some menu is active
1296                 if(device->isWindowActive() == false
1297                                 || noMenuActive() == false
1298                                 || guienv->hasFocus(gui_chat_console))
1299                 {
1300                         input->clear();
1301                 }
1302
1303                 // Input handler step() (used by the random input generator)
1304                 input->step(dtime);
1305
1306                 /*
1307                         Launch menus and trigger stuff according to keys
1308                 */
1309                 if(input->wasKeyDown(getKeySetting("keymap_drop")))
1310                 {
1311                         // drop selected item
1312                         IDropAction *a = new IDropAction();
1313                         a->count = 0;
1314                         a->from_inv.setCurrentPlayer();
1315                         a->from_list = "main";
1316                         a->from_i = client.getPlayerItem();
1317                         client.inventoryAction(a);
1318                 }
1319                 else if(input->wasKeyDown(getKeySetting("keymap_inventory")))
1320                 {
1321                         infostream<<"the_game: "
1322                                         <<"Launching inventory"<<std::endl;
1323
1324                         GUIInventoryMenu *menu =
1325                                 new GUIInventoryMenu(guienv, guiroot, -1,
1326                                         &g_menumgr, v2s16(8,7),
1327                                         &client, gamedef);
1328
1329                         InventoryLocation inventoryloc;
1330                         inventoryloc.setCurrentPlayer();
1331
1332                         core::array<GUIInventoryMenu::DrawSpec> draw_spec;
1333                         draw_spec.push_back(GUIInventoryMenu::DrawSpec(
1334                                         "list", inventoryloc, "main",
1335                                         v2s32(0, 3), v2s32(8, 4)));
1336                         draw_spec.push_back(GUIInventoryMenu::DrawSpec(
1337                                         "list", inventoryloc, "craft",
1338                                         v2s32(3, 0), v2s32(3, 3)));
1339                         draw_spec.push_back(GUIInventoryMenu::DrawSpec(
1340                                         "list", inventoryloc, "craftpreview",
1341                                         v2s32(7, 1), v2s32(1, 1)));
1342
1343                         menu->setDrawSpec(draw_spec);
1344
1345                         menu->drop();
1346                 }
1347                 else if(input->wasKeyDown(EscapeKey))
1348                 {
1349                         infostream<<"the_game: "
1350                                         <<"Launching pause menu"<<std::endl;
1351                         // It will delete itself by itself
1352                         (new GUIPauseMenu(guienv, guiroot, -1, g_gamecallback,
1353                                         &g_menumgr))->drop();
1354
1355                         // Move mouse cursor on top of the disconnect button
1356                         input->setMousePos(displaycenter.X, displaycenter.Y+25);
1357                 }
1358                 else if(input->wasKeyDown(getKeySetting("keymap_chat")))
1359                 {
1360                         TextDest *dest = new TextDestChat(&client);
1361
1362                         (new GUITextInputMenu(guienv, guiroot, -1,
1363                                         &g_menumgr, dest,
1364                                         L""))->drop();
1365                 }
1366                 else if(input->wasKeyDown(getKeySetting("keymap_cmd")))
1367                 {
1368                         TextDest *dest = new TextDestChat(&client);
1369
1370                         (new GUITextInputMenu(guienv, guiroot, -1,
1371                                         &g_menumgr, dest,
1372                                         L"/"))->drop();
1373                 }
1374                 else if(input->wasKeyDown(getKeySetting("keymap_console")))
1375                 {
1376                         if (!gui_chat_console->isOpenInhibited())
1377                         {
1378                                 // Open up to over half of the screen
1379                                 gui_chat_console->openConsole(0.6);
1380                                 guienv->setFocus(gui_chat_console);
1381                         }
1382                 }
1383                 else if(input->wasKeyDown(getKeySetting("keymap_freemove")))
1384                 {
1385                         if(g_settings->getBool("free_move"))
1386                         {
1387                                 g_settings->set("free_move","false");
1388                                 statustext = L"free_move disabled";
1389                                 statustext_time = 0;
1390                         }
1391                         else
1392                         {
1393                                 g_settings->set("free_move","true");
1394                                 statustext = L"free_move enabled";
1395                                 statustext_time = 0;
1396                         }
1397                 }
1398                 else if(input->wasKeyDown(getKeySetting("keymap_fastmove")))
1399                 {
1400                         if(g_settings->getBool("fast_move"))
1401                         {
1402                                 g_settings->set("fast_move","false");
1403                                 statustext = L"fast_move disabled";
1404                                 statustext_time = 0;
1405                         }
1406                         else
1407                         {
1408                                 g_settings->set("fast_move","true");
1409                                 statustext = L"fast_move enabled";
1410                                 statustext_time = 0;
1411                         }
1412                 }
1413                 else if(input->wasKeyDown(getKeySetting("keymap_screenshot")))
1414                 {
1415                         irr::video::IImage* const image = driver->createScreenShot();
1416                         if (image) {
1417                                 irr::c8 filename[256];
1418                                 snprintf(filename, 256, "%s" DIR_DELIM "screenshot_%u.png",
1419                                                  g_settings->get("screenshot_path").c_str(),
1420                                                  device->getTimer()->getRealTime());
1421                                 if (driver->writeImageToFile(image, filename)) {
1422                                         std::wstringstream sstr;
1423                                         sstr<<"Saved screenshot to '"<<filename<<"'";
1424                                         infostream<<"Saved screenshot to '"<<filename<<"'"<<std::endl;
1425                                         statustext = sstr.str();
1426                                         statustext_time = 0;
1427                                 } else{
1428                                         infostream<<"Failed to save screenshot '"<<filename<<"'"<<std::endl;
1429                                 }
1430                                 image->drop();
1431                         }
1432                 }
1433                 else if(input->wasKeyDown(getKeySetting("keymap_toggle_hud")))
1434                 {
1435                         show_hud = !show_hud;
1436                         if(show_hud)
1437                                 statustext = L"HUD shown";
1438                         else
1439                                 statustext = L"HUD hidden";
1440                         statustext_time = 0;
1441                 }
1442                 else if(input->wasKeyDown(getKeySetting("keymap_toggle_chat")))
1443                 {
1444                         show_chat = !show_chat;
1445                         if(show_chat)
1446                                 statustext = L"Chat shown";
1447                         else
1448                                 statustext = L"Chat hidden";
1449                         statustext_time = 0;
1450                 }
1451                 else if(input->wasKeyDown(getKeySetting("keymap_toggle_force_fog_off")))
1452                 {
1453                         force_fog_off = !force_fog_off;
1454                         if(force_fog_off)
1455                                 statustext = L"Fog disabled";
1456                         else
1457                                 statustext = L"Fog enabled";
1458                         statustext_time = 0;
1459                 }
1460                 else if(input->wasKeyDown(getKeySetting("keymap_toggle_update_camera")))
1461                 {
1462                         disable_camera_update = !disable_camera_update;
1463                         if(disable_camera_update)
1464                                 statustext = L"Camera update disabled";
1465                         else
1466                                 statustext = L"Camera update enabled";
1467                         statustext_time = 0;
1468                 }
1469                 else if(input->wasKeyDown(getKeySetting("keymap_toggle_debug")))
1470                 {
1471                         // Initial / 3x toggle: Chat only
1472                         // 1x toggle: Debug text with chat
1473                         // 2x toggle: Debug text with frametime
1474                         if(!show_debug)
1475                         {
1476                                 show_debug = true;
1477                                 show_debug_frametime = false;
1478                                 statustext = L"Debug info shown";
1479                                 statustext_time = 0;
1480                         }
1481                         else if(show_debug_frametime)
1482                         {
1483                                 show_debug = false;
1484                                 show_debug_frametime = false;
1485                                 statustext = L"Debug info and frametime graph hidden";
1486                                 statustext_time = 0;
1487                         }
1488                         else
1489                         {
1490                                 show_debug_frametime = true;
1491                                 statustext = L"Frametime graph shown";
1492                                 statustext_time = 0;
1493                         }
1494                 }
1495                 else if(input->wasKeyDown(getKeySetting("keymap_toggle_profiler")))
1496                 {
1497                         show_profiler = (show_profiler + 1) % (show_profiler_max + 1);
1498
1499                         // FIXME: This updates the profiler with incomplete values
1500                         update_profiler_gui(guitext_profiler, font, text_height,
1501                                         show_profiler, show_profiler_max);
1502
1503                         if(show_profiler != 0)
1504                         {
1505                                 std::wstringstream sstr;
1506                                 sstr<<"Profiler shown (page "<<show_profiler
1507                                         <<" of "<<show_profiler_max<<")";
1508                                 statustext = sstr.str();
1509                                 statustext_time = 0;
1510                         }
1511                         else
1512                         {
1513                                 statustext = L"Profiler hidden";
1514                                 statustext_time = 0;
1515                         }
1516                 }
1517                 else if(input->wasKeyDown(getKeySetting("keymap_increase_viewing_range_min")))
1518                 {
1519                         s16 range = g_settings->getS16("viewing_range_nodes_min");
1520                         s16 range_new = range + 10;
1521                         g_settings->set("viewing_range_nodes_min", itos(range_new));
1522                         statustext = narrow_to_wide(
1523                                         "Minimum viewing range changed to "
1524                                         + itos(range_new));
1525                         statustext_time = 0;
1526                 }
1527                 else if(input->wasKeyDown(getKeySetting("keymap_decrease_viewing_range_min")))
1528                 {
1529                         s16 range = g_settings->getS16("viewing_range_nodes_min");
1530                         s16 range_new = range - 10;
1531                         if(range_new < 0)
1532                                 range_new = range;
1533                         g_settings->set("viewing_range_nodes_min",
1534                                         itos(range_new));
1535                         statustext = narrow_to_wide(
1536                                         "Minimum viewing range changed to "
1537                                         + itos(range_new));
1538                         statustext_time = 0;
1539                 }
1540
1541                 // Item selection with mouse wheel
1542                 u16 new_playeritem = client.getPlayerItem();
1543                 {
1544                         s32 wheel = input->getMouseWheel();
1545                         u16 max_item = MYMIN(PLAYER_INVENTORY_SIZE-1,
1546                                         hotbar_itemcount-1);
1547
1548                         if(wheel < 0)
1549                         {
1550                                 if(new_playeritem < max_item)
1551                                         new_playeritem++;
1552                                 else
1553                                         new_playeritem = 0;
1554                         }
1555                         else if(wheel > 0)
1556                         {
1557                                 if(new_playeritem > 0)
1558                                         new_playeritem--;
1559                                 else
1560                                         new_playeritem = max_item;
1561                         }
1562                 }
1563
1564                 // Item selection
1565                 for(u16 i=0; i<10; i++)
1566                 {
1567                         const KeyPress *kp = NumberKey + (i + 1) % 10;
1568                         if(input->wasKeyDown(*kp))
1569                         {
1570                                 if(i < PLAYER_INVENTORY_SIZE && i < hotbar_itemcount)
1571                                 {
1572                                         new_playeritem = i;
1573
1574                                         infostream<<"Selected item: "
1575                                                         <<new_playeritem<<std::endl;
1576                                 }
1577                         }
1578                 }
1579
1580                 // Viewing range selection
1581                 if(input->wasKeyDown(getKeySetting("keymap_rangeselect")))
1582                 {
1583                         draw_control.range_all = !draw_control.range_all;
1584                         if(draw_control.range_all)
1585                         {
1586                                 infostream<<"Enabled full viewing range"<<std::endl;
1587                                 statustext = L"Enabled full viewing range";
1588                                 statustext_time = 0;
1589                         }
1590                         else
1591                         {
1592                                 infostream<<"Disabled full viewing range"<<std::endl;
1593                                 statustext = L"Disabled full viewing range";
1594                                 statustext_time = 0;
1595                         }
1596                 }
1597
1598                 // Print debug stacks
1599                 if(input->wasKeyDown(getKeySetting("keymap_print_debug_stacks")))
1600                 {
1601                         dstream<<"-----------------------------------------"
1602                                         <<std::endl;
1603                         dstream<<DTIME<<"Printing debug stacks:"<<std::endl;
1604                         dstream<<"-----------------------------------------"
1605                                         <<std::endl;
1606                         debug_stacks_print();
1607                 }
1608
1609                 /*
1610                         Mouse and camera control
1611                         NOTE: Do this before client.setPlayerControl() to not cause a camera lag of one frame
1612                 */
1613
1614                 if((device->isWindowActive() && noMenuActive()) || random_input)
1615                 {
1616                         if(!random_input)
1617                         {
1618                                 // Mac OSX gets upset if this is set every frame
1619                                 if(device->getCursorControl()->isVisible())
1620                                         device->getCursorControl()->setVisible(false);
1621                         }
1622
1623                         if(first_loop_after_window_activation){
1624                                 //infostream<<"window active, first loop"<<std::endl;
1625                                 first_loop_after_window_activation = false;
1626                         }
1627                         else{
1628                                 s32 dx = input->getMousePos().X - displaycenter.X;
1629                                 s32 dy = input->getMousePos().Y - displaycenter.Y;
1630                                 if(invert_mouse)
1631                                         dy = -dy;
1632                                 //infostream<<"window active, pos difference "<<dx<<","<<dy<<std::endl;
1633
1634                                 /*const float keyspeed = 500;
1635                                 if(input->isKeyDown(irr::KEY_UP))
1636                                         dy -= dtime * keyspeed;
1637                                 if(input->isKeyDown(irr::KEY_DOWN))
1638                                         dy += dtime * keyspeed;
1639                                 if(input->isKeyDown(irr::KEY_LEFT))
1640                                         dx -= dtime * keyspeed;
1641                                 if(input->isKeyDown(irr::KEY_RIGHT))
1642                                         dx += dtime * keyspeed;*/
1643
1644                                 camera_yaw -= dx*0.2;
1645                                 camera_pitch += dy*0.2;
1646                                 if(camera_pitch < -89.5) camera_pitch = -89.5;
1647                                 if(camera_pitch > 89.5) camera_pitch = 89.5;
1648                         }
1649                         input->setMousePos(displaycenter.X, displaycenter.Y);
1650                 }
1651                 else{
1652                         // Mac OSX gets upset if this is set every frame
1653                         if(device->getCursorControl()->isVisible() == false)
1654                                 device->getCursorControl()->setVisible(true);
1655
1656                         //infostream<<"window inactive"<<std::endl;
1657                         first_loop_after_window_activation = true;
1658                 }
1659
1660                 /*
1661                         Player speed control
1662                 */
1663                 {
1664                         /*bool a_up,
1665                         bool a_down,
1666                         bool a_left,
1667                         bool a_right,
1668                         bool a_jump,
1669                         bool a_superspeed,
1670                         bool a_sneak,
1671                         float a_pitch,
1672                         float a_yaw*/
1673                         PlayerControl control(
1674                                 input->isKeyDown(getKeySetting("keymap_forward")),
1675                                 input->isKeyDown(getKeySetting("keymap_backward")),
1676                                 input->isKeyDown(getKeySetting("keymap_left")),
1677                                 input->isKeyDown(getKeySetting("keymap_right")),
1678                                 input->isKeyDown(getKeySetting("keymap_jump")),
1679                                 input->isKeyDown(getKeySetting("keymap_special1")),
1680                                 input->isKeyDown(getKeySetting("keymap_sneak")),
1681                                 camera_pitch,
1682                                 camera_yaw
1683                         );
1684                         client.setPlayerControl(control);
1685                 }
1686
1687                 /*
1688                         Run server
1689                 */
1690
1691                 if(server != NULL)
1692                 {
1693                         //TimeTaker timer("server->step(dtime)");
1694                         server->step(dtime);
1695                 }
1696
1697                 /*
1698                         Process environment
1699                 */
1700
1701                 {
1702                         //TimeTaker timer("client.step(dtime)");
1703                         client.step(dtime);
1704                         //client.step(dtime_avg1);
1705                 }
1706
1707                 {
1708                         // Read client events
1709                         for(;;)
1710                         {
1711                                 ClientEvent event = client.getClientEvent();
1712                                 if(event.type == CE_NONE)
1713                                 {
1714                                         break;
1715                                 }
1716                                 else if(event.type == CE_PLAYER_DAMAGE)
1717                                 {
1718                                         //u16 damage = event.player_damage.amount;
1719                                         //infostream<<"Player damage: "<<damage<<std::endl;
1720                                         damage_flash_timer = 0.05;
1721                                         if(event.player_damage.amount >= 2){
1722                                                 damage_flash_timer += 0.05 * event.player_damage.amount;
1723                                         }
1724                                 }
1725                                 else if(event.type == CE_PLAYER_FORCE_MOVE)
1726                                 {
1727                                         camera_yaw = event.player_force_move.yaw;
1728                                         camera_pitch = event.player_force_move.pitch;
1729                                 }
1730                                 else if(event.type == CE_DEATHSCREEN)
1731                                 {
1732                                         if(respawn_menu_active)
1733                                                 continue;
1734
1735                                         /*bool set_camera_point_target =
1736                                                         event.deathscreen.set_camera_point_target;
1737                                         v3f camera_point_target;
1738                                         camera_point_target.X = event.deathscreen.camera_point_target_x;
1739                                         camera_point_target.Y = event.deathscreen.camera_point_target_y;
1740                                         camera_point_target.Z = event.deathscreen.camera_point_target_z;*/
1741                                         MainRespawnInitiator *respawner =
1742                                                         new MainRespawnInitiator(
1743                                                                         &respawn_menu_active, &client);
1744                                         GUIDeathScreen *menu =
1745                                                         new GUIDeathScreen(guienv, guiroot, -1,
1746                                                                 &g_menumgr, respawner);
1747                                         menu->drop();
1748
1749                                         chat_backend.addMessage(L"", L"You died.");
1750
1751                                         /* Handle visualization */
1752
1753                                         damage_flash_timer = 0;
1754
1755                                         /*LocalPlayer* player = client.getLocalPlayer();
1756                                         player->setPosition(player->getPosition() + v3f(0,-BS,0));
1757                                         camera.update(player, busytime, screensize);*/
1758                                 }
1759                                 else if(event.type == CE_TEXTURES_UPDATED)
1760                                 {
1761                                         update_skybox(driver, tsrc, smgr, skybox, brightness);
1762
1763                                         update_wielded_item_trigger = true;
1764                                 }
1765                         }
1766                 }
1767
1768                 //TimeTaker //timer2("//timer2");
1769
1770                 /*
1771                         For interaction purposes, get info about the held item
1772                         - What item is it?
1773                         - Is it a usable item?
1774                         - Can it point to liquids?
1775                 */
1776                 ItemStack playeritem;
1777                 bool playeritem_usable = false;
1778                 bool playeritem_liquids_pointable = false;
1779                 {
1780                         InventoryList *mlist = local_inventory.getList("main");
1781                         if(mlist != NULL)
1782                         {
1783                                 playeritem = mlist->getItem(client.getPlayerItem());
1784                                 playeritem_usable = playeritem.getDefinition(itemdef).usable;
1785                                 playeritem_liquids_pointable = playeritem.getDefinition(itemdef).liquids_pointable;
1786                         }
1787                 }
1788                 ToolCapabilities playeritem_toolcap =
1789                                 playeritem.getToolCapabilities(itemdef);
1790
1791                 /*
1792                         Update camera
1793                 */
1794
1795                 LocalPlayer* player = client.getLocalPlayer();
1796                 float full_punch_interval = playeritem_toolcap.full_punch_interval;
1797                 float tool_reload_ratio = time_from_last_punch / full_punch_interval;
1798                 tool_reload_ratio = MYMIN(tool_reload_ratio, 1.0);
1799                 camera.update(player, busytime, screensize, tool_reload_ratio);
1800                 camera.step(dtime);
1801
1802                 v3f player_position = player->getPosition();
1803                 v3f camera_position = camera.getPosition();
1804                 v3f camera_direction = camera.getDirection();
1805                 f32 camera_fov = camera.getFovMax();
1806
1807                 if(!disable_camera_update){
1808                         client.updateCamera(camera_position,
1809                                 camera_direction, camera_fov);
1810                 }
1811
1812                 //timer2.stop();
1813                 //TimeTaker //timer3("//timer3");
1814
1815                 /*
1816                         Calculate what block is the crosshair pointing to
1817                 */
1818
1819                 //u32 t1 = device->getTimer()->getRealTime();
1820
1821                 f32 d = 4; // max. distance
1822                 core::line3d<f32> shootline(camera_position,
1823                                 camera_position + camera_direction * BS * (d+1));
1824
1825                 core::aabbox3d<f32> hilightbox;
1826                 bool should_show_hilightbox = false;
1827                 ClientActiveObject *selected_object = NULL;
1828
1829                 PointedThing pointed = getPointedThing(
1830                                 // input
1831                                 &client, player_position, camera_direction,
1832                                 camera_position, shootline, d,
1833                                 playeritem_liquids_pointable, !ldown_for_dig,
1834                                 // output
1835                                 hilightbox, should_show_hilightbox,
1836                                 selected_object);
1837
1838                 if(pointed != pointed_old)
1839                 {
1840                         infostream<<"Pointing at "<<pointed.dump()<<std::endl;
1841                         //dstream<<"Pointing at "<<pointed.dump()<<std::endl;
1842                 }
1843
1844                 /*
1845                         Visualize selection
1846                 */
1847                 if(should_show_hilightbox)
1848                         hilightboxes.push_back(hilightbox);
1849
1850                 /*
1851                         Stop digging when
1852                         - releasing left mouse button
1853                         - pointing away from node
1854                 */
1855                 if(digging)
1856                 {
1857                         if(input->getLeftReleased())
1858                         {
1859                                 infostream<<"Left button released"
1860                                         <<" (stopped digging)"<<std::endl;
1861                                 digging = false;
1862                         }
1863                         else if(pointed != pointed_old)
1864                         {
1865                                 if (pointed.type == POINTEDTHING_NODE
1866                                         && pointed_old.type == POINTEDTHING_NODE
1867                                         && pointed.node_undersurface == pointed_old.node_undersurface)
1868                                 {
1869                                         // Still pointing to the same node,
1870                                         // but a different face. Don't reset.
1871                                 }
1872                                 else
1873                                 {
1874                                         infostream<<"Pointing away from node"
1875                                                 <<" (stopped digging)"<<std::endl;
1876                                         digging = false;
1877                                 }
1878                         }
1879                         if(!digging)
1880                         {
1881                                 client.interact(1, pointed_old);
1882                                 client.clearTempMod(pointed_old.node_undersurface);
1883                                 dig_time = 0.0;
1884                         }
1885                 }
1886                 if(!digging && ldown_for_dig && !input->getLeftState())
1887                 {
1888                         ldown_for_dig = false;
1889                 }
1890
1891                 bool left_punch = false;
1892
1893                 if(playeritem_usable && input->getLeftState())
1894                 {
1895                         if(input->getLeftClicked())
1896                                 client.interact(4, pointed);
1897                 }
1898                 else if(pointed.type == POINTEDTHING_NODE)
1899                 {
1900                         v3s16 nodepos = pointed.node_undersurface;
1901                         v3s16 neighbourpos = pointed.node_abovesurface;
1902
1903                         /*
1904                                 Check information text of node
1905                         */
1906
1907                         NodeMetadata *meta = client.getNodeMetadata(nodepos);
1908                         if(meta)
1909                         {
1910                                 infotext = narrow_to_wide(meta->infoText());
1911                         }
1912                         else
1913                         {
1914                                 MapNode n = client.getNode(nodepos);
1915                                 if(nodedef->get(n).tname_tiles[0] == "unknown_block.png"){
1916                                         infotext = L"Unknown node: ";
1917                                         infotext += narrow_to_wide(nodedef->get(n).name);
1918                                 }
1919                         }
1920
1921                         /*
1922                                 Handle digging
1923                         */
1924
1925
1926                         if(nodig_delay_timer <= 0.0 && input->getLeftState())
1927                         {
1928                                 if(!digging)
1929                                 {
1930                                         infostream<<"Started digging"<<std::endl;
1931                                         client.interact(0, pointed);
1932                                         digging = true;
1933                                         ldown_for_dig = true;
1934                                 }
1935                                 MapNode n = client.getNode(nodepos);
1936
1937                                 // Get digging parameters
1938                                 DigParams params = getDigParams(nodedef->get(n).groups,
1939                                                 &playeritem_toolcap);
1940                                 // If can't dig, try hand
1941                                 if(!params.diggable){
1942                                         const ItemDefinition &hand = itemdef->get("");
1943                                         const ToolCapabilities *tp = hand.tool_capabilities;
1944                                         if(tp)
1945                                                 params = getDigParams(nodedef->get(n).groups, tp);
1946                                 }
1947
1948                                 float dig_time_complete = 0.0;
1949
1950                                 if(params.diggable == false)
1951                                 {
1952                                         // I guess nobody will wait for this long
1953                                         dig_time_complete = 10000000.0;
1954                                 }
1955                                 else
1956                                 {
1957                                         dig_time_complete = params.time;
1958                                 }
1959
1960                                 if(dig_time_complete >= 0.001)
1961                                 {
1962                                         dig_index = (u16)((float)CRACK_ANIMATION_LENGTH
1963                                                         * dig_time/dig_time_complete);
1964                                 }
1965                                 // This is for torches
1966                                 else
1967                                 {
1968                                         dig_index = CRACK_ANIMATION_LENGTH;
1969                                 }
1970
1971                                 // Don't show cracks if not diggable
1972                                 if(dig_time_complete >= 100000.0)
1973                                 {
1974                                 }
1975                                 else if(dig_index < CRACK_ANIMATION_LENGTH)
1976                                 {
1977                                         //TimeTaker timer("client.setTempMod");
1978                                         //infostream<<"dig_index="<<dig_index<<std::endl;
1979                                         client.setTempMod(nodepos, NodeMod(NODEMOD_CRACK, dig_index));
1980                                 }
1981                                 else
1982                                 {
1983                                         infostream<<"Digging completed"<<std::endl;
1984                                         client.interact(2, pointed);
1985                                         client.clearTempMod(nodepos);
1986                                         client.removeNode(nodepos);
1987
1988                                         dig_time = 0;
1989                                         digging = false;
1990
1991                                         nodig_delay_timer = dig_time_complete
1992                                                         / (float)CRACK_ANIMATION_LENGTH;
1993
1994                                         // We don't want a corresponding delay to
1995                                         // very time consuming nodes
1996                                         if(nodig_delay_timer > 0.5)
1997                                         {
1998                                                 nodig_delay_timer = 0.5;
1999                                         }
2000                                         // We want a slight delay to very little
2001                                         // time consuming nodes
2002                                         float mindelay = 0.15;
2003                                         if(nodig_delay_timer < mindelay)
2004                                         {
2005                                                 nodig_delay_timer = mindelay;
2006                                         }
2007                                 }
2008
2009                                 dig_time += dtime;
2010
2011                                 camera.setDigging(0);  // left click animation
2012                         }
2013
2014                         if(input->getRightClicked())
2015                         {
2016                                 infostream<<"Ground right-clicked"<<std::endl;
2017
2018                                 // If metadata provides an inventory view, activate it
2019                                 if(meta && meta->getInventoryDrawSpecString() != "" && !random_input)
2020                                 {
2021                                         infostream<<"Launching custom inventory view"<<std::endl;
2022
2023                                         InventoryLocation inventoryloc;
2024                                         inventoryloc.setNodeMeta(nodepos);
2025
2026
2027                                         /*
2028                                                 Create menu
2029                                         */
2030
2031                                         core::array<GUIInventoryMenu::DrawSpec> draw_spec;
2032                                         v2s16 invsize =
2033                                                 GUIInventoryMenu::makeDrawSpecArrayFromString(
2034                                                         draw_spec,
2035                                                         meta->getInventoryDrawSpecString(),
2036                                                         inventoryloc);
2037
2038                                         GUIInventoryMenu *menu =
2039                                                 new GUIInventoryMenu(guienv, guiroot, -1,
2040                                                         &g_menumgr, invsize,
2041                                                         &client, gamedef);
2042                                         menu->setDrawSpec(draw_spec);
2043                                         menu->drop();
2044                                 }
2045                                 // If metadata provides text input, activate text input
2046                                 else if(meta && meta->allowsTextInput() && !random_input)
2047                                 {
2048                                         infostream<<"Launching metadata text input"<<std::endl;
2049
2050                                         // Get a new text for it
2051
2052                                         TextDest *dest = new TextDestNodeMetadata(nodepos, &client);
2053
2054                                         std::wstring wtext = narrow_to_wide(meta->getText());
2055
2056                                         (new GUITextInputMenu(guienv, guiroot, -1,
2057                                                         &g_menumgr, dest,
2058                                                         wtext))->drop();
2059                                 }
2060                                 // Otherwise report right click to server
2061                                 else
2062                                 {
2063                                         client.interact(3, pointed);
2064                                         camera.setDigging(1);  // right click animation
2065                                 }
2066                         }
2067                 }
2068                 else if(pointed.type == POINTEDTHING_OBJECT)
2069                 {
2070                         infotext = narrow_to_wide(selected_object->infoText());
2071
2072                         if(infotext == L"" && show_debug){
2073                                 infotext = narrow_to_wide(selected_object->debugInfoText());
2074                         }
2075
2076                         //if(input->getLeftClicked())
2077                         if(input->getLeftState())
2078                         {
2079                                 bool do_punch = false;
2080                                 bool do_punch_damage = false;
2081                                 if(object_hit_delay_timer <= 0.0){
2082                                         do_punch = true;
2083                                         do_punch_damage = true;
2084                                         object_hit_delay_timer = object_hit_delay;
2085                                 }
2086                                 if(input->getLeftClicked()){
2087                                         do_punch = true;
2088                                 }
2089                                 if(do_punch){
2090                                         infostream<<"Left-clicked object"<<std::endl;
2091                                         left_punch = true;
2092                                 }
2093                                 if(do_punch_damage){
2094                                         // Report direct punch
2095                                         v3f objpos = selected_object->getPosition();
2096                                         v3f dir = (objpos - player_position).normalize();
2097
2098                                         bool disable_send = selected_object->directReportPunch(
2099                                                         dir, &playeritem, time_from_last_punch);
2100                                         time_from_last_punch = 0;
2101                                         if(!disable_send)
2102                                                 client.interact(0, pointed);
2103                                 }
2104                         }
2105                         else if(input->getRightClicked())
2106                         {
2107                                 infostream<<"Right-clicked object"<<std::endl;
2108                                 client.interact(3, pointed);  // place
2109                         }
2110                 }
2111                 else if(input->getLeftState())
2112                 {
2113                         // When button is held down in air, show continuous animation
2114                         left_punch = true;
2115                 }
2116
2117                 pointed_old = pointed;
2118
2119                 if(left_punch || input->getLeftClicked())
2120                 {
2121                         camera.setDigging(0); // left click animation
2122                 }
2123
2124                 input->resetLeftClicked();
2125                 input->resetRightClicked();
2126
2127                 input->resetLeftReleased();
2128                 input->resetRightReleased();
2129
2130                 /*
2131                         Calculate stuff for drawing
2132                 */
2133
2134                 /*
2135                         Calculate general brightness
2136                 */
2137                 u32 daynight_ratio = client.getDayNightRatio();
2138                 u8 light8 = decode_light((daynight_ratio * LIGHT_SUN) / 1000);
2139                 brightness = (float)light8/255.0;
2140                 // Make night look good
2141                 brightness = brightness * 1.15 - 0.15;
2142                 video::SColor bgcolor;
2143                 if(brightness >= 0.2 && brightness < 0.7)
2144                         bgcolor = video::SColor(
2145                                         255,
2146                                         bgcolor_bright.getRed() * brightness,
2147                                         bgcolor_bright.getGreen() * brightness*0.7,
2148                                         bgcolor_bright.getBlue() * brightness*0.5);
2149                 else
2150                         bgcolor = video::SColor(
2151                                         255,
2152                                         bgcolor_bright.getRed() * brightness,
2153                                         bgcolor_bright.getGreen() * brightness,
2154                                         bgcolor_bright.getBlue() * brightness);
2155
2156                 /*
2157                         Update skybox
2158                 */
2159                 if(fabs(brightness - old_brightness) > 0.01)
2160                         update_skybox(driver, tsrc, smgr, skybox, brightness);
2161
2162                 /*
2163                         Update clouds
2164                 */
2165                 if(clouds)
2166                 {
2167                         clouds->step(dtime);
2168                         clouds->update(v2f(player_position.X, player_position.Z),
2169                                         brightness);
2170                 }
2171
2172                 /*
2173                         Update farmesh
2174                 */
2175                 if(farmesh)
2176                 {
2177                         farmesh_range = draw_control.wanted_range * 10;
2178                         if(draw_control.range_all && farmesh_range < 500)
2179                                 farmesh_range = 500;
2180                         if(farmesh_range > 1000)
2181                                 farmesh_range = 1000;
2182
2183                         farmesh->step(dtime);
2184                         farmesh->update(v2f(player_position.X, player_position.Z),
2185                                         brightness, farmesh_range);
2186                 }
2187
2188                 // Store brightness value
2189                 old_brightness = brightness;
2190
2191                 /*
2192                         Fog
2193                 */
2194
2195                 if(g_settings->getBool("enable_fog") == true && !force_fog_off)
2196                 {
2197                         f32 range;
2198                         if(farmesh)
2199                         {
2200                                 range = BS*farmesh_range;
2201                         }
2202                         else
2203                         {
2204                                 range = draw_control.wanted_range*BS + 0.0*MAP_BLOCKSIZE*BS;
2205                                 range *= 0.9;
2206                                 if(draw_control.range_all)
2207                                         range = 100000*BS;
2208                                 /*if(range < 50*BS)
2209                                         range = range * 0.5 + 25*BS;*/
2210                         }
2211
2212                         driver->setFog(
2213                                 bgcolor,
2214                                 video::EFT_FOG_LINEAR,
2215                                 range*0.4,
2216                                 range*1.0,
2217                                 0.01,
2218                                 false, // pixel fog
2219                                 false // range fog
2220                         );
2221                 }
2222                 else
2223                 {
2224                         driver->setFog(
2225                                 bgcolor,
2226                                 video::EFT_FOG_LINEAR,
2227                                 100000*BS,
2228                                 110000*BS,
2229                                 0.01,
2230                                 false, // pixel fog
2231                                 false // range fog
2232                         );
2233                 }
2234
2235                 /*
2236                         Update gui stuff (0ms)
2237                 */
2238
2239                 //TimeTaker guiupdatetimer("Gui updating");
2240
2241                 const char program_name_and_version[] =
2242                         "Minetest-c55 " VERSION_STRING;
2243
2244                 if(show_debug)
2245                 {
2246                         static float drawtime_avg = 0;
2247                         drawtime_avg = drawtime_avg * 0.95 + (float)drawtime*0.05;
2248                         /*static float beginscenetime_avg = 0;
2249                         beginscenetime_avg = beginscenetime_avg * 0.95 + (float)beginscenetime*0.05;
2250                         static float scenetime_avg = 0;
2251                         scenetime_avg = scenetime_avg * 0.95 + (float)scenetime*0.05;
2252                         static float endscenetime_avg = 0;
2253                         endscenetime_avg = endscenetime_avg * 0.95 + (float)endscenetime*0.05;*/
2254
2255                         char temptext[300];
2256                         snprintf(temptext, 300, "%s ("
2257                                         "R: range_all=%i"
2258                                         ")"
2259                                         " drawtime=%.0f, dtime_jitter = % .1f %%"
2260                                         ", v_range = %.1f, RTT = %.3f",
2261                                         program_name_and_version,
2262                                         draw_control.range_all,
2263                                         drawtime_avg,
2264                                         dtime_jitter1_max_fraction * 100.0,
2265                                         draw_control.wanted_range,
2266                                         client.getRTT()
2267                                         );
2268
2269                         guitext->setText(narrow_to_wide(temptext).c_str());
2270                         guitext->setVisible(true);
2271                 }
2272                 else if(show_hud || show_chat)
2273                 {
2274                         guitext->setText(narrow_to_wide(program_name_and_version).c_str());
2275                         guitext->setVisible(true);
2276                 }
2277                 else
2278                 {
2279                         guitext->setVisible(false);
2280                 }
2281
2282                 if(show_debug)
2283                 {
2284                         char temptext[300];
2285                         snprintf(temptext, 300,
2286                                         "(% .1f, % .1f, % .1f)"
2287                                         " (yaw = %.1f)",
2288                                         player_position.X/BS,
2289                                         player_position.Y/BS,
2290                                         player_position.Z/BS,
2291                                         wrapDegrees_0_360(camera_yaw));
2292
2293                         guitext2->setText(narrow_to_wide(temptext).c_str());
2294                         guitext2->setVisible(true);
2295                 }
2296                 else
2297                 {
2298                         guitext2->setVisible(false);
2299                 }
2300
2301                 {
2302                         guitext_info->setText(infotext.c_str());
2303                         guitext_info->setVisible(show_hud && g_menumgr.menuCount() == 0);
2304                 }
2305
2306                 {
2307                         float statustext_time_max = 3.0;
2308                         if(!statustext.empty())
2309                         {
2310                                 statustext_time += dtime;
2311                                 if(statustext_time >= statustext_time_max)
2312                                 {
2313                                         statustext = L"";
2314                                         statustext_time = 0;
2315                                 }
2316                         }
2317                         guitext_status->setText(statustext.c_str());
2318                         guitext_status->setVisible(!statustext.empty());
2319
2320                         if(!statustext.empty())
2321                         {
2322                                 s32 status_y = screensize.Y - 130;
2323                                 core::rect<s32> rect(
2324                                                 10,
2325                                                 status_y - guitext_status->getTextHeight(),
2326                                                 screensize.X - 10,
2327                                                 status_y
2328                                 );
2329                                 guitext_status->setRelativePosition(rect);
2330
2331                                 // Fade out
2332                                 video::SColor initial_color(255,0,0,0);
2333                                 if(guienv->getSkin())
2334                                         initial_color = guienv->getSkin()->getColor(gui::EGDC_BUTTON_TEXT);
2335                                 video::SColor final_color = initial_color;
2336                                 final_color.setAlpha(0);
2337                                 video::SColor fade_color =
2338                                         initial_color.getInterpolated_quadratic(
2339                                                 initial_color,
2340                                                 final_color,
2341                                                 statustext_time / (float) statustext_time_max);
2342                                 guitext_status->setOverrideColor(fade_color);
2343                                 guitext_status->enableOverrideColor(true);
2344                         }
2345                 }
2346
2347                 /*
2348                         Get chat messages from client
2349                 */
2350                 {
2351                         // Get new messages from error log buffer
2352                         while(!chat_log_error_buf.empty())
2353                         {
2354                                 chat_backend.addMessage(L"", narrow_to_wide(
2355                                                 chat_log_error_buf.get()));
2356                         }
2357                         // Get new messages from client
2358                         std::wstring message;
2359                         while(client.getChatMessage(message))
2360                         {
2361                                 chat_backend.addUnparsedMessage(message);
2362                         }
2363                         // Remove old messages
2364                         chat_backend.step(dtime);
2365
2366                         // Display all messages in a static text element
2367                         u32 recent_chat_count = chat_backend.getRecentBuffer().getLineCount();
2368                         std::wstring recent_chat = chat_backend.getRecentChat();
2369                         guitext_chat->setText(recent_chat.c_str());
2370
2371                         // Update gui element size and position
2372                         s32 chat_y = 5+(text_height+5);
2373                         if(show_debug)
2374                                 chat_y += (text_height+5);
2375                         core::rect<s32> rect(
2376                                 10,
2377                                 chat_y,
2378                                 screensize.X - 10,
2379                                 chat_y + guitext_chat->getTextHeight()
2380                         );
2381                         guitext_chat->setRelativePosition(rect);
2382
2383                         // Don't show chat if disabled or empty or profiler is enabled
2384                         guitext_chat->setVisible(show_chat && recent_chat_count != 0
2385                                         && !show_profiler);
2386                 }
2387
2388                 /*
2389                         Inventory
2390                 */
2391
2392                 if(client.getPlayerItem() != new_playeritem)
2393                 {
2394                         client.selectPlayerItem(new_playeritem);
2395                 }
2396                 if(client.getLocalInventoryUpdated())
2397                 {
2398                         //infostream<<"Updating local inventory"<<std::endl;
2399                         client.getLocalInventory(local_inventory);
2400
2401                         update_wielded_item_trigger = true;
2402                 }
2403                 if(update_wielded_item_trigger)
2404                 {
2405                         update_wielded_item_trigger = false;
2406                         // Update wielded tool
2407                         InventoryList *mlist = local_inventory.getList("main");
2408                         ItemStack item;
2409                         if(mlist != NULL)
2410                                 item = mlist->getItem(client.getPlayerItem());
2411                         camera.wield(item, gamedef);
2412                 }
2413
2414                 /*
2415                         Drawing begins
2416                 */
2417
2418                 TimeTaker drawtimer("Drawing");
2419
2420
2421                 {
2422                         TimeTaker timer("beginScene");
2423                         driver->beginScene(false, true, bgcolor);
2424                         //driver->beginScene(false, true, bgcolor);
2425                         beginscenetime = timer.stop(true);
2426                 }
2427
2428                 //timer3.stop();
2429
2430                 //infostream<<"smgr->drawAll()"<<std::endl;
2431
2432                 {
2433                         TimeTaker timer("smgr");
2434                         smgr->drawAll();
2435                         scenetime = timer.stop(true);
2436                 }
2437
2438                 {
2439                 //TimeTaker timer9("auxiliary drawings");
2440                 // 0ms
2441
2442                 //timer9.stop();
2443                 //TimeTaker //timer10("//timer10");
2444
2445                 video::SMaterial m;
2446                 //m.Thickness = 10;
2447                 m.Thickness = 3;
2448                 m.Lighting = false;
2449                 driver->setMaterial(m);
2450
2451                 driver->setTransform(video::ETS_WORLD, core::IdentityMatrix);
2452
2453                 if(show_hud)
2454                 {
2455                         for(core::list<aabb3f>::Iterator i=hilightboxes.begin();
2456                                         i != hilightboxes.end(); i++)
2457                         {
2458                                 /*infostream<<"hilightbox min="
2459                                                 <<"("<<i->MinEdge.X<<","<<i->MinEdge.Y<<","<<i->MinEdge.Z<<")"
2460                                                 <<" max="
2461                                                 <<"("<<i->MaxEdge.X<<","<<i->MaxEdge.Y<<","<<i->MaxEdge.Z<<")"
2462                                                 <<std::endl;*/
2463                                 driver->draw3DBox(*i, video::SColor(255,0,0,0));
2464                         }
2465                 }
2466
2467                 /*
2468                         Wielded tool
2469                 */
2470                 if(show_hud)
2471                 {
2472                         // Warning: This clears the Z buffer.
2473                         camera.drawWieldedTool();
2474                 }
2475
2476                 /*
2477                         Post effects
2478                 */
2479                 {
2480                         client.renderPostFx();
2481                 }
2482
2483                 /*
2484                         Frametime log
2485                 */
2486                 if(show_debug_frametime)
2487                 {
2488                         s32 x = 10;
2489                         s32 y = screensize.Y - 10;
2490                         for(core::list<float>::Iterator
2491                                         i = frametime_log.begin();
2492                                         i != frametime_log.end();
2493                                         i++)
2494                         {
2495                                 driver->draw2DLine(v2s32(x,y),
2496                                                 v2s32(x,y-(*i)*1000),
2497                                                 video::SColor(255,255,255,255));
2498                                 x++;
2499                         }
2500                 }
2501
2502                 /*
2503                         Draw crosshair
2504                 */
2505                 if(show_hud)
2506                 {
2507                         driver->draw2DLine(displaycenter - core::vector2d<s32>(10,0),
2508                                         displaycenter + core::vector2d<s32>(10,0),
2509                                         video::SColor(255,255,255,255));
2510                         driver->draw2DLine(displaycenter - core::vector2d<s32>(0,10),
2511                                         displaycenter + core::vector2d<s32>(0,10),
2512                                         video::SColor(255,255,255,255));
2513                 }
2514
2515                 } // timer
2516
2517                 //timer10.stop();
2518                 //TimeTaker //timer11("//timer11");
2519
2520                 /*
2521                         Draw gui
2522                 */
2523                 // 0-1ms
2524                 guienv->drawAll();
2525
2526                 /*
2527                         Draw hotbar
2528                 */
2529                 if(show_hud)
2530                 {
2531                         draw_hotbar(driver, font, gamedef,
2532                                         v2s32(displaycenter.X, screensize.Y),
2533                                         hotbar_imagesize, hotbar_itemcount, &local_inventory,
2534                                         client.getHP(), client.getPlayerItem());
2535                 }
2536
2537                 /*
2538                         Damage flash
2539                 */
2540                 if(damage_flash_timer > 0.0)
2541                 {
2542                         damage_flash_timer -= dtime;
2543
2544                         video::SColor color(128,255,0,0);
2545                         driver->draw2DRectangle(color,
2546                                         core::rect<s32>(0,0,screensize.X,screensize.Y),
2547                                         NULL);
2548                 }
2549
2550                 /*
2551                         End scene
2552                 */
2553                 {
2554                         TimeTaker timer("endScene");
2555                         endSceneX(driver);
2556                         endscenetime = timer.stop(true);
2557                 }
2558
2559                 drawtime = drawtimer.stop(true);
2560
2561                 /*
2562                         End of drawing
2563                 */
2564
2565                 static s16 lastFPS = 0;
2566                 //u16 fps = driver->getFPS();
2567                 u16 fps = (1.0/dtime_avg1);
2568
2569                 if (lastFPS != fps)
2570                 {
2571                         core::stringw str = L"Minetest [";
2572                         str += driver->getName();
2573                         str += "] FPS=";
2574                         str += fps;
2575
2576                         device->setWindowCaption(str.c_str());
2577                         lastFPS = fps;
2578                 }
2579         }
2580
2581         /*
2582                 Drop stuff
2583         */
2584         if(clouds)
2585                 clouds->drop();
2586         if(gui_chat_console)
2587                 gui_chat_console->drop();
2588
2589         /*
2590                 Draw a "shutting down" screen, which will be shown while the map
2591                 generator and other stuff quits
2592         */
2593         {
2594                 /*gui::IGUIStaticText *gui_shuttingdowntext = */
2595                 draw_load_screen(L"Shutting down stuff...", driver, font);
2596                 /*driver->beginScene(true, true, video::SColor(255,0,0,0));
2597                 guienv->drawAll();
2598                 driver->endScene();
2599                 gui_shuttingdowntext->remove();*/
2600         }
2601
2602         chat_backend.addMessage(L"", L"# Disconnected.");
2603         chat_backend.addMessage(L"", L"");
2604
2605         // Client scope (client is destructed before destructing *def and tsrc)
2606         }while(0);
2607
2608         delete tsrc;
2609         delete nodedef;
2610         delete itemdef;
2611 }
2612
2613