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                 errorstream<<"Couldn't resolve address"<<std::endl;
 741                 error_message = L"Couldn't resolve address";
 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                                 break;
 781                         }
 782                         if(input->wasKeyDown(EscapeKey)){
 783                                 connect_aborted = true;
 784                                 break;
 785                         }
 786
 787                         // Display status
 788                         std::wostringstream ss;
 789                         ss<<L"Connecting to server... (press Escape to cancel)\n";
 790                         std::wstring animation = L"/-\\|";
 791                         ss<<animation[(int)(time_counter/0.2)%4];
 792                         draw_load_screen(ss.str(), driver, font);
 793
 794                         // Delay a bit
 795                         sleep_ms(1000*frametime);
 796                         time_counter += frametime;
 797                 }
 798         }
 799         catch(con::PeerNotFoundException &e)
 800         {}
 801
 802         /*
 803                 Handle failure to connect
 804         */
 805         if(!could_connect){
 806                 if(error_message == L"" && !connect_aborted)
 807                         error_message = L"Connection failed";
 808                 // Break out of client scope
 809                 break;
 810         }
 811
 812         /*
 813                 Wait until content has been received
 814         */
 815         bool got_content = false;
 816         bool content_aborted = false;
 817         {
 818                 float frametime = 0.033;
 819                 float time_counter = 0.0;
 820                 input->clear();
 821                 while(device->run())
 822                 {
 823                         // Update client and server
 824                         client.step(frametime);
 825                         if(server != NULL)
 826                                 server->step(frametime);
 827
 828                         // End condition
 829                         if(client.texturesReceived() &&
 830                                         client.itemdefReceived() &&
 831                                         client.nodedefReceived()){
 832                                 got_content = true;
 833                                 break;
 834                         }
 835                         // Break conditions
 836                         if(!client.connectedAndInitialized()){
 837                                 error_message = L"Client disconnected";
 838                                 break;
 839                         }
 840                         if(input->wasKeyDown(EscapeKey)){
 841                                 content_aborted = true;
 842                                 break;
 843                         }
 844
 845                         // Display status
 846                         std::wostringstream ss;
 847                         ss<<L"Waiting content... (press Escape to cancel)\n";
 848
 849                         ss<<(client.itemdefReceived()?L"[X]":L"[  ]");
 850                         ss<<L" Item definitions\n";
 851                         ss<<(client.nodedefReceived()?L"[X]":L"[  ]");
 852                         ss<<L" Node definitions\n";
 853                         //ss<<(client.texturesReceived()?L"[X]":L"[  ]");
 854                         ss<<L"["<<(int)(client.textureReceiveProgress()*100+0.5)<<L"%] ";
 855                         ss<<L" Textures\n";
 856
 857                         draw_load_screen(ss.str(), driver, font);
 858
 859                         // Delay a bit
 860                         sleep_ms(1000*frametime);
 861                         time_counter += frametime;
 862                 }
 863         }
 864
 865         if(!got_content){
 866                 if(error_message == L"" && !content_aborted)
 867                         error_message = L"Something failed";
 868                 // Break out of client scope
 869                 break;
 870         }
 871
 872         /*
 873                 After all content has been received:
 874                 Update cached textures, meshes and materials
 875         */
 876         client.afterContentReceived();
 877
 878         /*
 879                 Create skybox
 880         */
 881         float old_brightness = 1.0;
 882         scene::ISceneNode* skybox = NULL;
 883         update_skybox(driver, tsrc, smgr, skybox, 1.0);
 884
 885         /*
 886                 Create the camera node
 887         */
 888         Camera camera(smgr, draw_control);
 889         if (!camera.successfullyCreated(error_message))
 890                 return;
 891
 892         f32 camera_yaw = 0; // "right/left"
 893         f32 camera_pitch = 0; // "up/down"
 894
 895         /*
 896                 Clouds
 897         */
 898
 899         float cloud_height = BS*100;
 900         Clouds *clouds = NULL;
 901         if(g_settings->getBool("enable_clouds"))
 902         {
 903                 clouds = new Clouds(smgr->getRootSceneNode(), smgr, -1,
 904                                 cloud_height, time(0));
 905         }
 906
 907         /*
 908                 FarMesh
 909         */
 910
 911         FarMesh *farmesh = NULL;
 912         if(g_settings->getBool("enable_farmesh"))
 913         {
 914                 farmesh = new FarMesh(smgr->getRootSceneNode(), smgr, -1, client.getMapSeed(), &client);
 915         }
 916
 917         /*
 918                 A copy of the local inventory
 919         */
 920         Inventory local_inventory(itemdef);
 921
 922         /*
 923                 Move into game
 924         */
 925
 926         //gui_loadingtext->remove();
 927
 928         /*
 929                 Add some gui stuff
 930         */
 931
 932         // First line of debug text
 933         gui::IGUIStaticText *guitext = guienv->addStaticText(
 934                         L"Minetest-c55",
 935                         core::rect<s32>(5, 5, 795, 5+text_height),
 936                         false, false);
 937         // Second line of debug text
 938         gui::IGUIStaticText *guitext2 = guienv->addStaticText(
 939                         L"",
 940                         core::rect<s32>(5, 5+(text_height+5)*1, 795, (5+text_height)*2),
 941                         false, false);
 942         // At the middle of the screen
 943         // Object infos are shown in this
 944         gui::IGUIStaticText *guitext_info = guienv->addStaticText(
 945                         L"",
 946                         core::rect<s32>(0,0,400,text_height*5+5) + v2s32(100,200),
 947                         false, false);
 948
 949         // Status text (displays info when showing and hiding GUI stuff, etc.)
 950         gui::IGUIStaticText *guitext_status = guienv->addStaticText(
 951                         L"<Status>",
 952                         core::rect<s32>(0,0,0,0),
 953                         false, false);
 954         guitext_status->setVisible(false);
 955
 956         std::wstring statustext;
 957         float statustext_time = 0;
 958
 959         // Chat text
 960         gui::IGUIStaticText *guitext_chat = guienv->addStaticText(
 961                         L"",
 962                         core::rect<s32>(0,0,0,0),
 963                         //false, false); // Disable word wrap as of now
 964                         false, true);
 965         // Remove stale "recent" chat messages from previous connections
 966         chat_backend.clearRecentChat();
 967         // Chat backend and console
 968         GUIChatConsole *gui_chat_console = new GUIChatConsole(guienv, guienv->getRootGUIElement(), -1, &chat_backend, &client);
 969
 970         // Profiler text (size is updated when text is updated)
 971         gui::IGUIStaticText *guitext_profiler = guienv->addStaticText(
 972                         L"<Profiler>",
 973                         core::rect<s32>(0,0,0,0),
 974                         false, false);
 975         guitext_profiler->setBackgroundColor(video::SColor(80,0,0,0));
 976         guitext_profiler->setVisible(false);
 977
 978         /*GUIQuickInventory *quick_inventory = new GUIQuickInventory
 979                         (guienv, NULL, v2s32(10, 70), 5, &local_inventory);*/
 980         /*GUIQuickInventory *quick_inventory = new GUIQuickInventory
 981                         (guienv, NULL, v2s32(0, 0), quickinv_itemcount, &local_inventory);*/
 982
 983         // Test the text input system
 984         /*(new GUITextInputMenu(guienv, guiroot, -1, &g_menumgr,
 985                         NULL))->drop();*/
 986         /*GUIMessageMenu *menu =
 987                         new GUIMessageMenu(guienv, guiroot, -1,
 988                                 &g_menumgr,
 989                                 L"Asd");
 990         menu->drop();*/
 991
 992         // Launch pause menu
 993         /*(new GUIPauseMenu(guienv, guiroot, -1, g_gamecallback,
 994                         &g_menumgr))->drop();*/
 995
 996         //s32 guitext_chat_pad_bottom = 70;
 997
 998         /*
 999                 Some statistics are collected in these
1000         */
1001         u32 drawtime = 0;
1002         u32 beginscenetime = 0;
1003         u32 scenetime = 0;
1004         u32 endscenetime = 0;
1005
1006         // A test
1007         //throw con::PeerNotFoundException("lol");
1008
1009         float brightness = 1.0;
1010
1011         core::list<float> frametime_log;
1012
1013         float nodig_delay_timer = 0.0;
1014         float dig_time = 0.0;
1015         u16 dig_index = 0;
1016         PointedThing pointed_old;
1017         bool digging = false;
1018         bool ldown_for_dig = false;
1019
1020         float damage_flash_timer = 0;
1021         s16 farmesh_range = 20*MAP_BLOCKSIZE;
1022
1023         const float object_hit_delay = 0.2;
1024         float object_hit_delay_timer = 0.0;
1025         float time_from_last_punch = 10;
1026
1027         bool invert_mouse = g_settings->getBool("invert_mouse");
1028
1029         bool respawn_menu_active = false;
1030         bool update_wielded_item_trigger = false;
1031
1032         bool show_hud = true;
1033         bool show_chat = true;
1034         bool force_fog_off = false;
1035         bool disable_camera_update = false;
1036         bool show_debug = g_settings->getBool("show_debug");
1037         bool show_debug_frametime = false;
1038         u32 show_profiler = 0;
1039         u32 show_profiler_max = 3;  // Number of pages
1040
1041         /*
1042                 Main loop
1043         */
1044
1045         bool first_loop_after_window_activation = true;
1046
1047         // TODO: Convert the static interval timers to these
1048         // Interval limiter for profiler
1049         IntervalLimiter m_profiler_interval;
1050
1051         // Time is in milliseconds
1052         // NOTE: getRealTime() causes strange problems in wine (imprecision?)
1053         // NOTE: So we have to use getTime() and call run()s between them
1054         u32 lasttime = device->getTimer()->getTime();
1055
1056         while(device->run() && kill == false)
1057         {
1058                 //std::cerr<<"frame"<<std::endl;
1059
1060                 if(client.accessDenied())
1061                 {
1062                         error_message = L"Access denied. Reason: "
1063                                         +client.accessDeniedReason();
1064                         errorstream<<wide_to_narrow(error_message)<<std::endl;
1065                         break;
1066                 }
1067
1068                 if(g_gamecallback->disconnect_requested)
1069                 {
1070                         g_gamecallback->disconnect_requested = false;
1071                         break;
1072                 }
1073
1074                 if(g_gamecallback->changepassword_requested)
1075                 {
1076                         (new GUIPasswordChange(guienv, guiroot, -1,
1077                                 &g_menumgr, &client))->drop();
1078                         g_gamecallback->changepassword_requested = false;
1079                 }
1080
1081                 /*
1082                         Process TextureSource's queue
1083                 */
1084                 tsrc->processQueue();
1085
1086                 /*
1087                         Random calculations
1088                 */
1089                 last_screensize = screensize;
1090                 screensize = driver->getScreenSize();
1091                 v2s32 displaycenter(screensize.X/2,screensize.Y/2);
1092                 //bool screensize_changed = screensize != last_screensize;
1093
1094                 // Resize hotbar
1095                 if(screensize.Y <= 800)
1096                         hotbar_imagesize = 32;
1097                 else if(screensize.Y <= 1280)
1098                         hotbar_imagesize = 48;
1099                 else
1100                         hotbar_imagesize = 64;
1101
1102                 // Hilight boxes collected during the loop and displayed
1103                 core::list< core::aabbox3d<f32> > hilightboxes;
1104
1105                 // Info text
1106                 std::wstring infotext;
1107
1108                 // When screen size changes, update positions and sizes of stuff
1109                 /*if(screensize_changed)
1110                 {
1111                         v2s32 pos(displaycenter.X-((quickinv_itemcount-1)*quickinv_spacing+quickinv_size)/2, screensize.Y-quickinv_spacing);
1112                         quick_inventory->updatePosition(pos);
1113                 }*/
1114
1115                 //TimeTaker //timer1("//timer1");
1116
1117                 // Time of frame without fps limit
1118                 float busytime;
1119                 u32 busytime_u32;
1120                 {
1121                         // not using getRealTime is necessary for wine
1122                         u32 time = device->getTimer()->getTime();
1123                         if(time > lasttime)
1124                                 busytime_u32 = time - lasttime;
1125                         else
1126                                 busytime_u32 = 0;
1127                         busytime = busytime_u32 / 1000.0;
1128                 }
1129
1130                 //infostream<<"busytime_u32="<<busytime_u32<<std::endl;
1131
1132                 // Necessary for device->getTimer()->getTime()
1133                 device->run();
1134
1135                 /*
1136                         FPS limiter
1137                 */
1138
1139                 {
1140                         float fps_max = g_settings->getFloat("fps_max");
1141                         u32 frametime_min = 1000./fps_max;
1142
1143                         if(busytime_u32 < frametime_min)
1144                         {
1145                                 u32 sleeptime = frametime_min - busytime_u32;
1146                                 device->sleep(sleeptime);
1147                         }
1148                 }
1149
1150                 // Necessary for device->getTimer()->getTime()
1151                 device->run();
1152
1153                 /*
1154                         Time difference calculation
1155                 */
1156                 f32 dtime; // in seconds
1157
1158                 u32 time = device->getTimer()->getTime();
1159                 if(time > lasttime)
1160                         dtime = (time - lasttime) / 1000.0;
1161                 else
1162                         dtime = 0;
1163                 lasttime = time;
1164
1165                 /* Run timers */
1166
1167                 if(nodig_delay_timer >= 0)
1168                         nodig_delay_timer -= dtime;
1169                 if(object_hit_delay_timer >= 0)
1170                         object_hit_delay_timer -= dtime;
1171                 time_from_last_punch += dtime;
1172
1173                 g_profiler->add("Elapsed time", dtime);
1174                 g_profiler->avg("FPS", 1./dtime);
1175
1176                 /*
1177                         Log frametime for visualization
1178                 */
1179                 frametime_log.push_back(dtime);
1180                 if(frametime_log.size() > 100)
1181                 {
1182                         core::list<float>::Iterator i = frametime_log.begin();
1183                         frametime_log.erase(i);
1184                 }
1185
1186                 /*
1187                         Visualize frametime in terminal
1188                 */
1189                 /*for(u32 i=0; i<dtime*400; i++)
1190                         infostream<<"X";
1191                 infostream<<std::endl;*/
1192
1193                 /*
1194                         Time average and jitter calculation
1195                 */
1196
1197                 static f32 dtime_avg1 = 0.0;
1198                 dtime_avg1 = dtime_avg1 * 0.96 + dtime * 0.04;
1199                 f32 dtime_jitter1 = dtime - dtime_avg1;
1200
1201                 static f32 dtime_jitter1_max_sample = 0.0;
1202                 static f32 dtime_jitter1_max_fraction = 0.0;
1203                 {
1204                         static f32 jitter1_max = 0.0;
1205                         static f32 counter = 0.0;
1206                         if(dtime_jitter1 > jitter1_max)
1207                                 jitter1_max = dtime_jitter1;
1208                         counter += dtime;
1209                         if(counter > 0.0)
1210                         {
1211                                 counter -= 3.0;
1212                                 dtime_jitter1_max_sample = jitter1_max;
1213                                 dtime_jitter1_max_fraction
1214                                                 = dtime_jitter1_max_sample / (dtime_avg1+0.001);
1215                                 jitter1_max = 0.0;
1216                         }
1217                 }
1218
1219                 /*
1220                         Busytime average and jitter calculation
1221                 */
1222
1223                 static f32 busytime_avg1 = 0.0;
1224                 busytime_avg1 = busytime_avg1 * 0.98 + busytime * 0.02;
1225                 f32 busytime_jitter1 = busytime - busytime_avg1;
1226
1227                 static f32 busytime_jitter1_max_sample = 0.0;
1228                 static f32 busytime_jitter1_min_sample = 0.0;
1229                 {
1230                         static f32 jitter1_max = 0.0;
1231                         static f32 jitter1_min = 0.0;
1232                         static f32 counter = 0.0;
1233                         if(busytime_jitter1 > jitter1_max)
1234                                 jitter1_max = busytime_jitter1;
1235                         if(busytime_jitter1 < jitter1_min)
1236                                 jitter1_min = busytime_jitter1;
1237                         counter += dtime;
1238                         if(counter > 0.0){
1239                                 counter -= 3.0;
1240                                 busytime_jitter1_max_sample = jitter1_max;
1241                                 busytime_jitter1_min_sample = jitter1_min;
1242                                 jitter1_max = 0.0;
1243                                 jitter1_min = 0.0;
1244                         }
1245                 }
1246
1247                 /*
1248                         Debug info for client
1249                 */
1250                 {
1251                         static float counter = 0.0;
1252                         counter -= dtime;
1253                         if(counter < 0)
1254                         {
1255                                 counter = 30.0;
1256                                 client.printDebugInfo(infostream);
1257                         }
1258                 }
1259
1260                 /*
1261                         Profiler
1262                 */
1263                 float profiler_print_interval =
1264                                 g_settings->getFloat("profiler_print_interval");
1265                 bool print_to_log = true;
1266                 if(profiler_print_interval == 0){
1267                         print_to_log = false;
1268                         profiler_print_interval = 5;
1269                 }
1270                 if(m_profiler_interval.step(dtime, profiler_print_interval))
1271                 {
1272                         if(print_to_log){
1273                                 infostream<<"Profiler:"<<std::endl;
1274                                 g_profiler->print(infostream);
1275                         }
1276
1277                         update_profiler_gui(guitext_profiler, font, text_height,
1278                                         show_profiler, show_profiler_max);
1279
1280                         g_profiler->clear();
1281                 }
1282
1283                 /*
1284                         Direct handling of user input
1285                 */
1286
1287                 // Reset input if window not active or some menu is active
1288                 if(device->isWindowActive() == false
1289                                 || noMenuActive() == false
1290                                 || guienv->hasFocus(gui_chat_console))
1291                 {
1292                         input->clear();
1293                 }
1294
1295                 // Input handler step() (used by the random input generator)
1296                 input->step(dtime);
1297
1298                 /*
1299                         Launch menus and trigger stuff according to keys
1300                 */
1301                 if(input->wasKeyDown(getKeySetting("keymap_drop")))
1302                 {
1303                         // drop selected item
1304                         IDropAction *a = new IDropAction();
1305                         a->count = 0;
1306                         a->from_inv.setCurrentPlayer();
1307                         a->from_list = "main";
1308                         a->from_i = client.getPlayerItem();
1309                         client.inventoryAction(a);
1310                 }
1311                 else if(input->wasKeyDown(getKeySetting("keymap_inventory")))
1312                 {
1313                         infostream<<"the_game: "
1314                                         <<"Launching inventory"<<std::endl;
1315
1316                         GUIInventoryMenu *menu =
1317                                 new GUIInventoryMenu(guienv, guiroot, -1,
1318                                         &g_menumgr, v2s16(8,7),
1319                                         &client, gamedef);
1320
1321                         InventoryLocation inventoryloc;
1322                         inventoryloc.setCurrentPlayer();
1323
1324                         core::array<GUIInventoryMenu::DrawSpec> draw_spec;
1325                         draw_spec.push_back(GUIInventoryMenu::DrawSpec(
1326                                         "list", inventoryloc, "main",
1327                                         v2s32(0, 3), v2s32(8, 4)));
1328                         draw_spec.push_back(GUIInventoryMenu::DrawSpec(
1329                                         "list", inventoryloc, "craft",
1330                                         v2s32(3, 0), v2s32(3, 3)));
1331                         draw_spec.push_back(GUIInventoryMenu::DrawSpec(
1332                                         "list", inventoryloc, "craftpreview",
1333                                         v2s32(7, 1), v2s32(1, 1)));
1334
1335                         menu->setDrawSpec(draw_spec);
1336
1337                         menu->drop();
1338                 }
1339                 else if(input->wasKeyDown(EscapeKey))
1340                 {
1341                         infostream<<"the_game: "
1342                                         <<"Launching pause menu"<<std::endl;
1343                         // It will delete itself by itself
1344                         (new GUIPauseMenu(guienv, guiroot, -1, g_gamecallback,
1345                                         &g_menumgr))->drop();
1346
1347                         // Move mouse cursor on top of the disconnect button
1348                         input->setMousePos(displaycenter.X, displaycenter.Y+25);
1349                 }
1350                 else if(input->wasKeyDown(getKeySetting("keymap_chat")))
1351                 {
1352                         TextDest *dest = new TextDestChat(&client);
1353
1354                         (new GUITextInputMenu(guienv, guiroot, -1,
1355                                         &g_menumgr, dest,
1356                                         L""))->drop();
1357                 }
1358                 else if(input->wasKeyDown(getKeySetting("keymap_cmd")))
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_console")))
1367                 {
1368                         if (!gui_chat_console->isOpenInhibited())
1369                         {
1370                                 // Open up to over half of the screen
1371                                 gui_chat_console->openConsole(0.6);
1372                                 guienv->setFocus(gui_chat_console);
1373                         }
1374                 }
1375                 else if(input->wasKeyDown(getKeySetting("keymap_freemove")))
1376                 {
1377                         if(g_settings->getBool("free_move"))
1378                         {
1379                                 g_settings->set("free_move","false");
1380                                 statustext = L"free_move disabled";
1381                                 statustext_time = 0;
1382                         }
1383                         else
1384                         {
1385                                 g_settings->set("free_move","true");
1386                                 statustext = L"free_move enabled";
1387                                 statustext_time = 0;
1388                         }
1389                 }
1390                 else if(input->wasKeyDown(getKeySetting("keymap_fastmove")))
1391                 {
1392                         if(g_settings->getBool("fast_move"))
1393                         {
1394                                 g_settings->set("fast_move","false");
1395                                 statustext = L"fast_move disabled";
1396                                 statustext_time = 0;
1397                         }
1398                         else
1399                         {
1400                                 g_settings->set("fast_move","true");
1401                                 statustext = L"fast_move enabled";
1402                                 statustext_time = 0;
1403                         }
1404                 }
1405                 else if(input->wasKeyDown(getKeySetting("keymap_screenshot")))
1406                 {
1407                         irr::video::IImage* const image = driver->createScreenShot();
1408                         if (image) {
1409                                 irr::c8 filename[256];
1410                                 snprintf(filename, 256, "%s" DIR_DELIM "screenshot_%u.png",
1411                                                  g_settings->get("screenshot_path").c_str(),
1412                                                  device->getTimer()->getRealTime());
1413                                 if (driver->writeImageToFile(image, filename)) {
1414                                         std::wstringstream sstr;
1415                                         sstr<<"Saved screenshot to '"<<filename<<"'";
1416                                         infostream<<"Saved screenshot to '"<<filename<<"'"<<std::endl;
1417                                         statustext = sstr.str();
1418                                         statustext_time = 0;
1419                                 } else{
1420                                         infostream<<"Failed to save screenshot '"<<filename<<"'"<<std::endl;
1421                                 }
1422                                 image->drop();
1423                         }
1424                 }
1425                 else if(input->wasKeyDown(getKeySetting("keymap_toggle_hud")))
1426                 {
1427                         show_hud = !show_hud;
1428                         if(show_hud)
1429                                 statustext = L"HUD shown";
1430                         else
1431                                 statustext = L"HUD hidden";
1432                         statustext_time = 0;
1433                 }
1434                 else if(input->wasKeyDown(getKeySetting("keymap_toggle_chat")))
1435                 {
1436                         show_chat = !show_chat;
1437                         if(show_chat)
1438                                 statustext = L"Chat shown";
1439                         else
1440                                 statustext = L"Chat hidden";
1441                         statustext_time = 0;
1442                 }
1443                 else if(input->wasKeyDown(getKeySetting("keymap_toggle_force_fog_off")))
1444                 {
1445                         force_fog_off = !force_fog_off;
1446                         if(force_fog_off)
1447                                 statustext = L"Fog disabled";
1448                         else
1449                                 statustext = L"Fog enabled";
1450                         statustext_time = 0;
1451                 }
1452                 else if(input->wasKeyDown(getKeySetting("keymap_toggle_update_camera")))
1453                 {
1454                         disable_camera_update = !disable_camera_update;
1455                         if(disable_camera_update)
1456                                 statustext = L"Camera update disabled";
1457                         else
1458                                 statustext = L"Camera update enabled";
1459                         statustext_time = 0;
1460                 }
1461                 else if(input->wasKeyDown(getKeySetting("keymap_toggle_debug")))
1462                 {
1463                         // Initial / 3x toggle: Chat only
1464                         // 1x toggle: Debug text with chat
1465                         // 2x toggle: Debug text with frametime
1466                         if(!show_debug)
1467                         {
1468                                 show_debug = true;
1469                                 show_debug_frametime = false;
1470                                 statustext = L"Debug info shown";
1471                                 statustext_time = 0;
1472                         }
1473                         else if(show_debug_frametime)
1474                         {
1475                                 show_debug = false;
1476                                 show_debug_frametime = false;
1477                                 statustext = L"Debug info and frametime graph hidden";
1478                                 statustext_time = 0;
1479                         }
1480                         else
1481                         {
1482                                 show_debug_frametime = true;
1483                                 statustext = L"Frametime graph shown";
1484                                 statustext_time = 0;
1485                         }
1486                 }
1487                 else if(input->wasKeyDown(getKeySetting("keymap_toggle_profiler")))
1488                 {
1489                         show_profiler = (show_profiler + 1) % (show_profiler_max + 1);
1490
1491                         // FIXME: This updates the profiler with incomplete values
1492                         update_profiler_gui(guitext_profiler, font, text_height,
1493                                         show_profiler, show_profiler_max);
1494
1495                         if(show_profiler != 0)
1496                         {
1497                                 std::wstringstream sstr;
1498                                 sstr<<"Profiler shown (page "<<show_profiler
1499                                         <<" of "<<show_profiler_max<<")";
1500                                 statustext = sstr.str();
1501                                 statustext_time = 0;
1502                         }
1503                         else
1504                         {
1505                                 statustext = L"Profiler hidden";
1506                                 statustext_time = 0;
1507                         }
1508                 }
1509                 else if(input->wasKeyDown(getKeySetting("keymap_increase_viewing_range_min")))
1510                 {
1511                         s16 range = g_settings->getS16("viewing_range_nodes_min");
1512                         s16 range_new = range + 10;
1513                         g_settings->set("viewing_range_nodes_min", itos(range_new));
1514                         statustext = narrow_to_wide(
1515                                         "Minimum viewing range changed to "
1516                                         + itos(range_new));
1517                         statustext_time = 0;
1518                 }
1519                 else if(input->wasKeyDown(getKeySetting("keymap_decrease_viewing_range_min")))
1520                 {
1521                         s16 range = g_settings->getS16("viewing_range_nodes_min");
1522                         s16 range_new = range - 10;
1523                         if(range_new < 0)
1524                                 range_new = range;
1525                         g_settings->set("viewing_range_nodes_min",
1526                                         itos(range_new));
1527                         statustext = narrow_to_wide(
1528                                         "Minimum viewing range changed to "
1529                                         + itos(range_new));
1530                         statustext_time = 0;
1531                 }
1532
1533                 // Item selection with mouse wheel
1534                 u16 new_playeritem = client.getPlayerItem();
1535                 {
1536                         s32 wheel = input->getMouseWheel();
1537                         u16 max_item = MYMIN(PLAYER_INVENTORY_SIZE-1,
1538                                         hotbar_itemcount-1);
1539
1540                         if(wheel < 0)
1541                         {
1542                                 if(new_playeritem < max_item)
1543                                         new_playeritem++;
1544                                 else
1545                                         new_playeritem = 0;
1546                         }
1547                         else if(wheel > 0)
1548                         {
1549                                 if(new_playeritem > 0)
1550                                         new_playeritem--;
1551                                 else
1552                                         new_playeritem = max_item;
1553                         }
1554                 }
1555
1556                 // Item selection
1557                 for(u16 i=0; i<10; i++)
1558                 {
1559                         const KeyPress *kp = NumberKey + (i + 1) % 10;
1560                         if(input->wasKeyDown(*kp))
1561                         {
1562                                 if(i < PLAYER_INVENTORY_SIZE && i < hotbar_itemcount)
1563                                 {
1564                                         new_playeritem = i;
1565
1566                                         infostream<<"Selected item: "
1567                                                         <<new_playeritem<<std::endl;
1568                                 }
1569                         }
1570                 }
1571
1572                 // Viewing range selection
1573                 if(input->wasKeyDown(getKeySetting("keymap_rangeselect")))
1574                 {
1575                         draw_control.range_all = !draw_control.range_all;
1576                         if(draw_control.range_all)
1577                         {
1578                                 infostream<<"Enabled full viewing range"<<std::endl;
1579                                 statustext = L"Enabled full viewing range";
1580                                 statustext_time = 0;
1581                         }
1582                         else
1583                         {
1584                                 infostream<<"Disabled full viewing range"<<std::endl;
1585                                 statustext = L"Disabled full viewing range";
1586                                 statustext_time = 0;
1587                         }
1588                 }
1589
1590                 // Print debug stacks
1591                 if(input->wasKeyDown(getKeySetting("keymap_print_debug_stacks")))
1592                 {
1593                         dstream<<"-----------------------------------------"
1594                                         <<std::endl;
1595                         dstream<<DTIME<<"Printing debug stacks:"<<std::endl;
1596                         dstream<<"-----------------------------------------"
1597                                         <<std::endl;
1598                         debug_stacks_print();
1599                 }
1600
1601                 /*
1602                         Mouse and camera control
1603                         NOTE: Do this before client.setPlayerControl() to not cause a camera lag of one frame
1604                 */
1605
1606                 if((device->isWindowActive() && noMenuActive()) || random_input)
1607                 {
1608                         if(!random_input)
1609                         {
1610                                 // Mac OSX gets upset if this is set every frame
1611                                 if(device->getCursorControl()->isVisible())
1612                                         device->getCursorControl()->setVisible(false);
1613                         }
1614
1615                         if(first_loop_after_window_activation){
1616                                 //infostream<<"window active, first loop"<<std::endl;
1617                                 first_loop_after_window_activation = false;
1618                         }
1619                         else{
1620                                 s32 dx = input->getMousePos().X - displaycenter.X;
1621                                 s32 dy = input->getMousePos().Y - displaycenter.Y;
1622                                 if(invert_mouse)
1623                                         dy = -dy;
1624                                 //infostream<<"window active, pos difference "<<dx<<","<<dy<<std::endl;
1625
1626                                 /*const float keyspeed = 500;
1627                                 if(input->isKeyDown(irr::KEY_UP))
1628                                         dy -= dtime * keyspeed;
1629                                 if(input->isKeyDown(irr::KEY_DOWN))
1630                                         dy += dtime * keyspeed;
1631                                 if(input->isKeyDown(irr::KEY_LEFT))
1632                                         dx -= dtime * keyspeed;
1633                                 if(input->isKeyDown(irr::KEY_RIGHT))
1634                                         dx += dtime * keyspeed;*/
1635
1636                                 camera_yaw -= dx*0.2;
1637                                 camera_pitch += dy*0.2;
1638                                 if(camera_pitch < -89.5) camera_pitch = -89.5;
1639                                 if(camera_pitch > 89.5) camera_pitch = 89.5;
1640                         }
1641                         input->setMousePos(displaycenter.X, displaycenter.Y);
1642                 }
1643                 else{
1644                         // Mac OSX gets upset if this is set every frame
1645                         if(device->getCursorControl()->isVisible() == false)
1646                                 device->getCursorControl()->setVisible(true);
1647
1648                         //infostream<<"window inactive"<<std::endl;
1649                         first_loop_after_window_activation = true;
1650                 }
1651
1652                 /*
1653                         Player speed control
1654                 */
1655                 {
1656                         /*bool a_up,
1657                         bool a_down,
1658                         bool a_left,
1659                         bool a_right,
1660                         bool a_jump,
1661                         bool a_superspeed,
1662                         bool a_sneak,
1663                         float a_pitch,
1664                         float a_yaw*/
1665                         PlayerControl control(
1666                                 input->isKeyDown(getKeySetting("keymap_forward")),
1667                                 input->isKeyDown(getKeySetting("keymap_backward")),
1668                                 input->isKeyDown(getKeySetting("keymap_left")),
1669                                 input->isKeyDown(getKeySetting("keymap_right")),
1670                                 input->isKeyDown(getKeySetting("keymap_jump")),
1671                                 input->isKeyDown(getKeySetting("keymap_special1")),
1672                                 input->isKeyDown(getKeySetting("keymap_sneak")),
1673                                 camera_pitch,
1674                                 camera_yaw
1675                         );
1676                         client.setPlayerControl(control);
1677                 }
1678
1679                 /*
1680                         Run server
1681                 */
1682
1683                 if(server != NULL)
1684                 {
1685                         //TimeTaker timer("server->step(dtime)");
1686                         server->step(dtime);
1687                 }
1688
1689                 /*
1690                         Process environment
1691                 */
1692
1693                 {
1694                         //TimeTaker timer("client.step(dtime)");
1695                         client.step(dtime);
1696                         //client.step(dtime_avg1);
1697                 }
1698
1699                 {
1700                         // Read client events
1701                         for(;;)
1702                         {
1703                                 ClientEvent event = client.getClientEvent();
1704                                 if(event.type == CE_NONE)
1705                                 {
1706                                         break;
1707                                 }
1708                                 else if(event.type == CE_PLAYER_DAMAGE)
1709                                 {
1710                                         //u16 damage = event.player_damage.amount;
1711                                         //infostream<<"Player damage: "<<damage<<std::endl;
1712                                         damage_flash_timer = 0.05;
1713                                         if(event.player_damage.amount >= 2){
1714                                                 damage_flash_timer += 0.05 * event.player_damage.amount;
1715                                         }
1716                                 }
1717                                 else if(event.type == CE_PLAYER_FORCE_MOVE)
1718                                 {
1719                                         camera_yaw = event.player_force_move.yaw;
1720                                         camera_pitch = event.player_force_move.pitch;
1721                                 }
1722                                 else if(event.type == CE_DEATHSCREEN)
1723                                 {
1724                                         if(respawn_menu_active)
1725                                                 continue;
1726
1727                                         /*bool set_camera_point_target =
1728                                                         event.deathscreen.set_camera_point_target;
1729                                         v3f camera_point_target;
1730                                         camera_point_target.X = event.deathscreen.camera_point_target_x;
1731                                         camera_point_target.Y = event.deathscreen.camera_point_target_y;
1732                                         camera_point_target.Z = event.deathscreen.camera_point_target_z;*/
1733                                         MainRespawnInitiator *respawner =
1734                                                         new MainRespawnInitiator(
1735                                                                         &respawn_menu_active, &client);
1736                                         GUIDeathScreen *menu =
1737                                                         new GUIDeathScreen(guienv, guiroot, -1,
1738                                                                 &g_menumgr, respawner);
1739                                         menu->drop();
1740
1741                                         chat_backend.addMessage(L"", L"You died.");
1742
1743                                         /* Handle visualization */
1744
1745                                         damage_flash_timer = 0;
1746
1747                                         /*LocalPlayer* player = client.getLocalPlayer();
1748                                         player->setPosition(player->getPosition() + v3f(0,-BS,0));
1749                                         camera.update(player, busytime, screensize);*/
1750                                 }
1751                                 else if(event.type == CE_TEXTURES_UPDATED)
1752                                 {
1753                                         update_skybox(driver, tsrc, smgr, skybox, brightness);
1754
1755                                         update_wielded_item_trigger = true;
1756                                 }
1757                         }
1758                 }
1759
1760                 //TimeTaker //timer2("//timer2");
1761
1762                 /*
1763                         For interaction purposes, get info about the held item
1764                         - What item is it?
1765                         - Is it a usable item?
1766                         - Can it point to liquids?
1767                 */
1768                 ItemStack playeritem;
1769                 bool playeritem_usable = false;
1770                 bool playeritem_liquids_pointable = false;
1771                 {
1772                         InventoryList *mlist = local_inventory.getList("main");
1773                         if(mlist != NULL)
1774                         {
1775                                 playeritem = mlist->getItem(client.getPlayerItem());
1776                                 playeritem_usable = playeritem.getDefinition(itemdef).usable;
1777                                 playeritem_liquids_pointable = playeritem.getDefinition(itemdef).liquids_pointable;
1778                         }
1779                 }
1780                 ToolCapabilities playeritem_toolcap =
1781                                 playeritem.getToolCapabilities(itemdef);
1782
1783                 /*
1784                         Update camera
1785                 */
1786
1787                 LocalPlayer* player = client.getLocalPlayer();
1788                 float full_punch_interval = playeritem_toolcap.full_punch_interval;
1789                 float tool_reload_ratio = time_from_last_punch / full_punch_interval;
1790                 tool_reload_ratio = MYMIN(tool_reload_ratio, 1.0);
1791                 camera.update(player, busytime, screensize, tool_reload_ratio);
1792                 camera.step(dtime);
1793
1794                 v3f player_position = player->getPosition();
1795                 v3f camera_position = camera.getPosition();
1796                 v3f camera_direction = camera.getDirection();
1797                 f32 camera_fov = camera.getFovMax();
1798
1799                 if(!disable_camera_update){
1800                         client.updateCamera(camera_position,
1801                                 camera_direction, camera_fov);
1802                 }
1803
1804                 //timer2.stop();
1805                 //TimeTaker //timer3("//timer3");
1806
1807                 /*
1808                         Calculate what block is the crosshair pointing to
1809                 */
1810
1811                 //u32 t1 = device->getTimer()->getRealTime();
1812
1813                 f32 d = 4; // max. distance
1814                 core::line3d<f32> shootline(camera_position,
1815                                 camera_position + camera_direction * BS * (d+1));
1816
1817                 core::aabbox3d<f32> hilightbox;
1818                 bool should_show_hilightbox = false;
1819                 ClientActiveObject *selected_object = NULL;
1820
1821                 PointedThing pointed = getPointedThing(
1822                                 // input
1823                                 &client, player_position, camera_direction,
1824                                 camera_position, shootline, d,
1825                                 playeritem_liquids_pointable, !ldown_for_dig,
1826                                 // output
1827                                 hilightbox, should_show_hilightbox,
1828                                 selected_object);
1829
1830                 if(pointed != pointed_old)
1831                 {
1832                         infostream<<"Pointing at "<<pointed.dump()<<std::endl;
1833                         //dstream<<"Pointing at "<<pointed.dump()<<std::endl;
1834                 }
1835
1836                 /*
1837                         Visualize selection
1838                 */
1839                 if(should_show_hilightbox)
1840                         hilightboxes.push_back(hilightbox);
1841
1842                 /*
1843                         Stop digging when
1844                         - releasing left mouse button
1845                         - pointing away from node
1846                 */
1847                 if(digging)
1848                 {
1849                         if(input->getLeftReleased())
1850                         {
1851                                 infostream<<"Left button released"
1852                                         <<" (stopped digging)"<<std::endl;
1853                                 digging = false;
1854                         }
1855                         else if(pointed != pointed_old)
1856                         {
1857                                 if (pointed.type == POINTEDTHING_NODE
1858                                         && pointed_old.type == POINTEDTHING_NODE
1859                                         && pointed.node_undersurface == pointed_old.node_undersurface)
1860                                 {
1861                                         // Still pointing to the same node,
1862                                         // but a different face. Don't reset.
1863                                 }
1864                                 else
1865                                 {
1866                                         infostream<<"Pointing away from node"
1867                                                 <<" (stopped digging)"<<std::endl;
1868                                         digging = false;
1869                                 }
1870                         }
1871                         if(!digging)
1872                         {
1873                                 client.interact(1, pointed_old);
1874                                 client.clearTempMod(pointed_old.node_undersurface);
1875                                 dig_time = 0.0;
1876                         }
1877                 }
1878                 if(!digging && ldown_for_dig && !input->getLeftState())
1879                 {
1880                         ldown_for_dig = false;
1881                 }
1882
1883                 bool left_punch = false;
1884                 bool left_punch_muted = false;
1885
1886                 if(playeritem_usable && input->getLeftState())
1887                 {
1888                         if(input->getLeftClicked())
1889                                 client.interact(4, pointed);
1890                 }
1891                 else if(pointed.type == POINTEDTHING_NODE)
1892                 {
1893                         v3s16 nodepos = pointed.node_undersurface;
1894                         v3s16 neighbourpos = pointed.node_abovesurface;
1895
1896                         /*
1897                                 Check information text of node
1898                         */
1899
1900                         NodeMetadata *meta = client.getNodeMetadata(nodepos);
1901                         if(meta)
1902                         {
1903                                 infotext = narrow_to_wide(meta->infoText());
1904                         }
1905                         else
1906                         {
1907                                 MapNode n = client.getNode(nodepos);
1908                                 if(nodedef->get(n).tname_tiles[0] == "unknown_block.png"){
1909                                         infotext = L"Unknown node: ";
1910                                         infotext += narrow_to_wide(nodedef->get(n).name);
1911                                 }
1912                         }
1913
1914                         /*
1915                                 Handle digging
1916                         */
1917
1918
1919                         if(nodig_delay_timer <= 0.0 && input->getLeftState())
1920                         {
1921                                 if(!digging)
1922                                 {
1923                                         infostream<<"Started digging"<<std::endl;
1924                                         client.interact(0, pointed);
1925                                         digging = true;
1926                                         ldown_for_dig = true;
1927                                 }
1928                                 MapNode n = client.getNode(nodepos);
1929
1930                                 // Get digging parameters
1931                                 DigParams params = getDigParams(nodedef->get(n).groups,
1932                                                 &playeritem_toolcap);
1933                                 // If can't dig, try hand
1934                                 if(!params.diggable){
1935                                         const ItemDefinition &hand = itemdef->get("");
1936                                         const ToolCapabilities *tp = hand.tool_capabilities;
1937                                         if(tp)
1938                                                 params = getDigParams(nodedef->get(n).groups, tp);
1939                                 }
1940
1941                                 float dig_time_complete = 0.0;
1942
1943                                 if(params.diggable == false)
1944                                 {
1945                                         // I guess nobody will wait for this long
1946                                         dig_time_complete = 10000000.0;
1947                                 }
1948                                 else
1949                                 {
1950                                         dig_time_complete = params.time;
1951                                 }
1952
1953                                 if(dig_time_complete >= 0.001)
1954                                 {
1955                                         dig_index = (u16)((float)CRACK_ANIMATION_LENGTH
1956                                                         * dig_time/dig_time_complete);
1957                                 }
1958                                 // This is for torches
1959                                 else
1960                                 {
1961                                         dig_index = CRACK_ANIMATION_LENGTH;
1962                                 }
1963
1964                                 // Don't show cracks if not diggable
1965                                 if(dig_time_complete >= 100000.0)
1966                                 {
1967                                 }
1968                                 else if(dig_index < CRACK_ANIMATION_LENGTH)
1969                                 {
1970                                         //TimeTaker timer("client.setTempMod");
1971                                         //infostream<<"dig_index="<<dig_index<<std::endl;
1972                                         client.setTempMod(nodepos, NodeMod(NODEMOD_CRACK, dig_index));
1973                                 }
1974                                 else
1975                                 {
1976                                         infostream<<"Digging completed"<<std::endl;
1977                                         client.interact(2, pointed);
1978                                         client.clearTempMod(nodepos);
1979                                         client.removeNode(nodepos);
1980
1981                                         dig_time = 0;
1982                                         digging = false;
1983
1984                                         nodig_delay_timer = dig_time_complete
1985                                                         / (float)CRACK_ANIMATION_LENGTH;
1986
1987                                         // We don't want a corresponding delay to
1988                                         // very time consuming nodes
1989                                         if(nodig_delay_timer > 0.5)
1990                                         {
1991                                                 nodig_delay_timer = 0.5;
1992                                         }
1993                                         // We want a slight delay to very little
1994                                         // time consuming nodes
1995                                         float mindelay = 0.15;
1996                                         if(nodig_delay_timer < mindelay)
1997                                         {
1998                                                 nodig_delay_timer = mindelay;
1999                                         }
2000                                 }
2001
2002                                 dig_time += dtime;
2003
2004                                 camera.setDigging(0);  // left click animation
2005                         }
2006
2007                         if(input->getRightClicked())
2008                         {
2009                                 infostream<<"Ground right-clicked"<<std::endl;
2010
2011                                 // If metadata provides an inventory view, activate it
2012                                 if(meta && meta->getInventoryDrawSpecString() != "" && !random_input)
2013                                 {
2014                                         infostream<<"Launching custom inventory view"<<std::endl;
2015
2016                                         InventoryLocation inventoryloc;
2017                                         inventoryloc.setNodeMeta(nodepos);
2018
2019
2020                                         /*
2021                                                 Create menu
2022                                         */
2023
2024                                         core::array<GUIInventoryMenu::DrawSpec> draw_spec;
2025                                         v2s16 invsize =
2026                                                 GUIInventoryMenu::makeDrawSpecArrayFromString(
2027                                                         draw_spec,
2028                                                         meta->getInventoryDrawSpecString(),
2029                                                         inventoryloc);
2030
2031                                         GUIInventoryMenu *menu =
2032                                                 new GUIInventoryMenu(guienv, guiroot, -1,
2033                                                         &g_menumgr, invsize,
2034                                                         &client, gamedef);
2035                                         menu->setDrawSpec(draw_spec);
2036                                         menu->drop();
2037                                 }
2038                                 // If metadata provides text input, activate text input
2039                                 else if(meta && meta->allowsTextInput() && !random_input)
2040                                 {
2041                                         infostream<<"Launching metadata text input"<<std::endl;
2042
2043                                         // Get a new text for it
2044
2045                                         TextDest *dest = new TextDestNodeMetadata(nodepos, &client);
2046
2047                                         std::wstring wtext = narrow_to_wide(meta->getText());
2048
2049                                         (new GUITextInputMenu(guienv, guiroot, -1,
2050                                                         &g_menumgr, dest,
2051                                                         wtext))->drop();
2052                                 }
2053                                 // Otherwise report right click to server
2054                                 else
2055                                 {
2056                                         client.interact(3, pointed);
2057                                         camera.setDigging(1);  // right click animation
2058                                 }
2059                         }
2060                 }
2061                 else if(pointed.type == POINTEDTHING_OBJECT)
2062                 {
2063                         infotext = narrow_to_wide(selected_object->infoText());
2064
2065                         if(infotext == L"" && show_debug){
2066                                 infotext = narrow_to_wide(selected_object->debugInfoText());
2067                         }
2068
2069                         //if(input->getLeftClicked())
2070                         if(input->getLeftState())
2071                         {
2072                                 bool do_punch = false;
2073                                 bool do_punch_damage = false;
2074                                 if(object_hit_delay_timer <= 0.0){
2075                                         do_punch = true;
2076                                         do_punch_damage = true;
2077                                         object_hit_delay_timer = object_hit_delay;
2078                                 }
2079                                 if(input->getLeftClicked()){
2080                                         do_punch = true;
2081                                 }
2082                                 if(do_punch){
2083                                         infostream<<"Left-clicked object"<<std::endl;
2084                                         left_punch = true;
2085                                 }
2086                                 if(do_punch_damage){
2087                                         // Report direct punch
2088                                         v3f objpos = selected_object->getPosition();
2089                                         v3f dir = (objpos - player_position).normalize();
2090
2091                                         bool disable_send = selected_object->directReportPunch(
2092                                                         dir, &playeritem, time_from_last_punch);
2093                                         time_from_last_punch = 0;
2094                                         if(!disable_send)
2095                                                 client.interact(0, pointed);
2096                                 }
2097                         }
2098                         else if(input->getRightClicked())
2099                         {
2100                                 infostream<<"Right-clicked object"<<std::endl;
2101                                 client.interact(3, pointed);  // place
2102                         }
2103                 }
2104
2105                 pointed_old = pointed;
2106
2107                 if(left_punch || (input->getLeftClicked() && !left_punch_muted))
2108                 {
2109                         camera.setDigging(0); // left click animation
2110                 }
2111
2112                 input->resetLeftClicked();
2113                 input->resetRightClicked();
2114
2115                 input->resetLeftReleased();
2116                 input->resetRightReleased();
2117
2118                 /*
2119                         Calculate stuff for drawing
2120                 */
2121
2122                 /*
2123                         Calculate general brightness
2124                 */
2125                 u32 daynight_ratio = client.getDayNightRatio();
2126                 u8 light8 = decode_light((daynight_ratio * LIGHT_SUN) / 1000);
2127                 brightness = (float)light8/255.0;
2128                 // Make night look good
2129                 brightness = brightness * 1.15 - 0.15;
2130                 video::SColor bgcolor;
2131                 if(brightness >= 0.2 && brightness < 0.7)
2132                         bgcolor = video::SColor(
2133                                         255,
2134                                         bgcolor_bright.getRed() * brightness,
2135                                         bgcolor_bright.getGreen() * brightness*0.7,
2136                                         bgcolor_bright.getBlue() * brightness*0.5);
2137                 else
2138                         bgcolor = video::SColor(
2139                                         255,
2140                                         bgcolor_bright.getRed() * brightness,
2141                                         bgcolor_bright.getGreen() * brightness,
2142                                         bgcolor_bright.getBlue() * brightness);
2143
2144                 /*
2145                         Update skybox
2146                 */
2147                 if(fabs(brightness - old_brightness) > 0.01)
2148                         update_skybox(driver, tsrc, smgr, skybox, brightness);
2149
2150                 /*
2151                         Update clouds
2152                 */
2153                 if(clouds)
2154                 {
2155                         clouds->step(dtime);
2156                         clouds->update(v2f(player_position.X, player_position.Z),
2157                                         brightness);
2158                 }
2159
2160                 /*
2161                         Update farmesh
2162                 */
2163                 if(farmesh)
2164                 {
2165                         farmesh_range = draw_control.wanted_range * 10;
2166                         if(draw_control.range_all && farmesh_range < 500)
2167                                 farmesh_range = 500;
2168                         if(farmesh_range > 1000)
2169                                 farmesh_range = 1000;
2170
2171                         farmesh->step(dtime);
2172                         farmesh->update(v2f(player_position.X, player_position.Z),
2173                                         brightness, farmesh_range);
2174                 }
2175
2176                 // Store brightness value
2177                 old_brightness = brightness;
2178
2179                 /*
2180                         Fog
2181                 */
2182
2183                 if(g_settings->getBool("enable_fog") == true && !force_fog_off)
2184                 {
2185                         f32 range;
2186                         if(farmesh)
2187                         {
2188                                 range = BS*farmesh_range;
2189                         }
2190                         else
2191                         {
2192                                 range = draw_control.wanted_range*BS + 0.0*MAP_BLOCKSIZE*BS;
2193                                 range *= 0.9;
2194                                 if(draw_control.range_all)
2195                                         range = 100000*BS;
2196                                 /*if(range < 50*BS)
2197                                         range = range * 0.5 + 25*BS;*/
2198                         }
2199
2200                         driver->setFog(
2201                                 bgcolor,
2202                                 video::EFT_FOG_LINEAR,
2203                                 range*0.4,
2204                                 range*1.0,
2205                                 0.01,
2206                                 false, // pixel fog
2207                                 false // range fog
2208                         );
2209                 }
2210                 else
2211                 {
2212                         driver->setFog(
2213                                 bgcolor,
2214                                 video::EFT_FOG_LINEAR,
2215                                 100000*BS,
2216                                 110000*BS,
2217                                 0.01,
2218                                 false, // pixel fog
2219                                 false // range fog
2220                         );
2221                 }
2222
2223                 /*
2224                         Update gui stuff (0ms)
2225                 */
2226
2227                 //TimeTaker guiupdatetimer("Gui updating");
2228
2229                 const char program_name_and_version[] =
2230                         "Minetest-c55 " VERSION_STRING;
2231
2232                 if(show_debug)
2233                 {
2234                         static float drawtime_avg = 0;
2235                         drawtime_avg = drawtime_avg * 0.95 + (float)drawtime*0.05;
2236                         /*static float beginscenetime_avg = 0;
2237                         beginscenetime_avg = beginscenetime_avg * 0.95 + (float)beginscenetime*0.05;
2238                         static float scenetime_avg = 0;
2239                         scenetime_avg = scenetime_avg * 0.95 + (float)scenetime*0.05;
2240                         static float endscenetime_avg = 0;
2241                         endscenetime_avg = endscenetime_avg * 0.95 + (float)endscenetime*0.05;*/
2242
2243                         char temptext[300];
2244                         snprintf(temptext, 300, "%s ("
2245                                         "R: range_all=%i"
2246                                         ")"
2247                                         " drawtime=%.0f, dtime_jitter = % .1f %%"
2248                                         ", v_range = %.1f, RTT = %.3f",
2249                                         program_name_and_version,
2250                                         draw_control.range_all,
2251                                         drawtime_avg,
2252                                         dtime_jitter1_max_fraction * 100.0,
2253                                         draw_control.wanted_range,
2254                                         client.getRTT()
2255                                         );
2256
2257                         guitext->setText(narrow_to_wide(temptext).c_str());
2258                         guitext->setVisible(true);
2259                 }
2260                 else if(show_hud || show_chat)
2261                 {
2262                         guitext->setText(narrow_to_wide(program_name_and_version).c_str());
2263                         guitext->setVisible(true);
2264                 }
2265                 else
2266                 {
2267                         guitext->setVisible(false);
2268                 }
2269
2270                 if(show_debug)
2271                 {
2272                         char temptext[300];
2273                         snprintf(temptext, 300,
2274                                         "(% .1f, % .1f, % .1f)"
2275                                         " (yaw = %.1f)",
2276                                         player_position.X/BS,
2277                                         player_position.Y/BS,
2278                                         player_position.Z/BS,
2279                                         wrapDegrees_0_360(camera_yaw));
2280
2281                         guitext2->setText(narrow_to_wide(temptext).c_str());
2282                         guitext2->setVisible(true);
2283                 }
2284                 else
2285                 {
2286                         guitext2->setVisible(false);
2287                 }
2288
2289                 {
2290                         guitext_info->setText(infotext.c_str());
2291                         guitext_info->setVisible(show_hud && g_menumgr.menuCount() == 0);
2292                 }
2293
2294                 {
2295                         float statustext_time_max = 3.0;
2296                         if(!statustext.empty())
2297                         {
2298                                 statustext_time += dtime;
2299                                 if(statustext_time >= statustext_time_max)
2300                                 {
2301                                         statustext = L"";
2302                                         statustext_time = 0;
2303                                 }
2304                         }
2305                         guitext_status->setText(statustext.c_str());
2306                         guitext_status->setVisible(!statustext.empty());
2307
2308                         if(!statustext.empty())
2309                         {
2310                                 s32 status_y = screensize.Y - 130;
2311                                 core::rect<s32> rect(
2312                                                 10,
2313                                                 status_y - guitext_status->getTextHeight(),
2314                                                 screensize.X - 10,
2315                                                 status_y
2316                                 );
2317                                 guitext_status->setRelativePosition(rect);
2318
2319                                 // Fade out
2320                                 video::SColor initial_color(255,0,0,0);
2321                                 if(guienv->getSkin())
2322                                         initial_color = guienv->getSkin()->getColor(gui::EGDC_BUTTON_TEXT);
2323                                 video::SColor final_color = initial_color;
2324                                 final_color.setAlpha(0);
2325                                 video::SColor fade_color =
2326                                         initial_color.getInterpolated_quadratic(
2327                                                 initial_color,
2328                                                 final_color,
2329                                                 statustext_time / (float) statustext_time_max);
2330                                 guitext_status->setOverrideColor(fade_color);
2331                                 guitext_status->enableOverrideColor(true);
2332                         }
2333                 }
2334
2335                 /*
2336                         Get chat messages from client
2337                 */
2338                 {
2339                         // Get new messages from error log buffer
2340                         while(!chat_log_error_buf.empty())
2341                         {
2342                                 chat_backend.addMessage(L"", narrow_to_wide(
2343                                                 chat_log_error_buf.get()));
2344                         }
2345                         // Get new messages from client
2346                         std::wstring message;
2347                         while(client.getChatMessage(message))
2348                         {
2349                                 chat_backend.addUnparsedMessage(message);
2350                         }
2351                         // Remove old messages
2352                         chat_backend.step(dtime);
2353
2354                         // Display all messages in a static text element
2355                         u32 recent_chat_count = chat_backend.getRecentBuffer().getLineCount();
2356                         std::wstring recent_chat = chat_backend.getRecentChat();
2357                         guitext_chat->setText(recent_chat.c_str());
2358
2359                         // Update gui element size and position
2360                         s32 chat_y = 5+(text_height+5);
2361                         if(show_debug)
2362                                 chat_y += (text_height+5);
2363                         core::rect<s32> rect(
2364                                 10,
2365                                 chat_y,
2366                                 screensize.X - 10,
2367                                 chat_y + guitext_chat->getTextHeight()
2368                         );
2369                         guitext_chat->setRelativePosition(rect);
2370
2371                         // Don't show chat if disabled or empty or profiler is enabled
2372                         guitext_chat->setVisible(show_chat && recent_chat_count != 0
2373                                         && !show_profiler);
2374                 }
2375
2376                 /*
2377                         Inventory
2378                 */
2379
2380                 if(client.getPlayerItem() != new_playeritem)
2381                 {
2382                         client.selectPlayerItem(new_playeritem);
2383                 }
2384                 if(client.getLocalInventoryUpdated())
2385                 {
2386                         //infostream<<"Updating local inventory"<<std::endl;
2387                         client.getLocalInventory(local_inventory);
2388
2389                         update_wielded_item_trigger = true;
2390                 }
2391                 if(update_wielded_item_trigger)
2392                 {
2393                         update_wielded_item_trigger = false;
2394                         // Update wielded tool
2395                         InventoryList *mlist = local_inventory.getList("main");
2396                         ItemStack item;
2397                         if(mlist != NULL)
2398                                 item = mlist->getItem(client.getPlayerItem());
2399                         camera.wield(item, gamedef);
2400                 }
2401
2402                 /*
2403                         Drawing begins
2404                 */
2405
2406                 TimeTaker drawtimer("Drawing");
2407
2408
2409                 {
2410                         TimeTaker timer("beginScene");
2411                         driver->beginScene(false, true, bgcolor);
2412                         //driver->beginScene(false, true, bgcolor);
2413                         beginscenetime = timer.stop(true);
2414                 }
2415
2416                 //timer3.stop();
2417
2418                 //infostream<<"smgr->drawAll()"<<std::endl;
2419
2420                 {
2421                         TimeTaker timer("smgr");
2422                         smgr->drawAll();
2423                         scenetime = timer.stop(true);
2424                 }
2425
2426                 {
2427                 //TimeTaker timer9("auxiliary drawings");
2428                 // 0ms
2429
2430                 //timer9.stop();
2431                 //TimeTaker //timer10("//timer10");
2432
2433                 video::SMaterial m;
2434                 //m.Thickness = 10;
2435                 m.Thickness = 3;
2436                 m.Lighting = false;
2437                 driver->setMaterial(m);
2438
2439                 driver->setTransform(video::ETS_WORLD, core::IdentityMatrix);
2440
2441                 if(show_hud)
2442                 {
2443                         for(core::list<aabb3f>::Iterator i=hilightboxes.begin();
2444                                         i != hilightboxes.end(); i++)
2445                         {
2446                                 /*infostream<<"hilightbox min="
2447                                                 <<"("<<i->MinEdge.X<<","<<i->MinEdge.Y<<","<<i->MinEdge.Z<<")"
2448                                                 <<" max="
2449                                                 <<"("<<i->MaxEdge.X<<","<<i->MaxEdge.Y<<","<<i->MaxEdge.Z<<")"
2450                                                 <<std::endl;*/
2451                                 driver->draw3DBox(*i, video::SColor(255,0,0,0));
2452                         }
2453                 }
2454
2455                 /*
2456                         Wielded tool
2457                 */
2458                 if(show_hud)
2459                 {
2460                         // Warning: This clears the Z buffer.
2461                         camera.drawWieldedTool();
2462                 }
2463
2464                 /*
2465                         Post effects
2466                 */
2467                 {
2468                         client.renderPostFx();
2469                 }
2470
2471                 /*
2472                         Frametime log
2473                 */
2474                 if(show_debug_frametime)
2475                 {
2476                         s32 x = 10;
2477                         s32 y = screensize.Y - 10;
2478                         for(core::list<float>::Iterator
2479                                         i = frametime_log.begin();
2480                                         i != frametime_log.end();
2481                                         i++)
2482                         {
2483                                 driver->draw2DLine(v2s32(x,y),
2484                                                 v2s32(x,y-(*i)*1000),
2485                                                 video::SColor(255,255,255,255));
2486                                 x++;
2487                         }
2488                 }
2489
2490                 /*
2491                         Draw crosshair
2492                 */
2493                 if(show_hud)
2494                 {
2495                         driver->draw2DLine(displaycenter - core::vector2d<s32>(10,0),
2496                                         displaycenter + core::vector2d<s32>(10,0),
2497                                         video::SColor(255,255,255,255));
2498                         driver->draw2DLine(displaycenter - core::vector2d<s32>(0,10),
2499                                         displaycenter + core::vector2d<s32>(0,10),
2500                                         video::SColor(255,255,255,255));
2501                 }
2502
2503                 } // timer
2504
2505                 //timer10.stop();
2506                 //TimeTaker //timer11("//timer11");
2507
2508                 /*
2509                         Draw gui
2510                 */
2511                 // 0-1ms
2512                 guienv->drawAll();
2513
2514                 /*
2515                         Draw hotbar
2516                 */
2517                 if(show_hud)
2518                 {
2519                         draw_hotbar(driver, font, gamedef,
2520                                         v2s32(displaycenter.X, screensize.Y),
2521                                         hotbar_imagesize, hotbar_itemcount, &local_inventory,
2522                                         client.getHP(), client.getPlayerItem());
2523                 }
2524
2525                 /*
2526                         Damage flash
2527                 */
2528                 if(damage_flash_timer > 0.0)
2529                 {
2530                         damage_flash_timer -= dtime;
2531
2532                         video::SColor color(128,255,0,0);
2533                         driver->draw2DRectangle(color,
2534                                         core::rect<s32>(0,0,screensize.X,screensize.Y),
2535                                         NULL);
2536                 }
2537
2538                 /*
2539                         End scene
2540                 */
2541                 {
2542                         TimeTaker timer("endScene");
2543                         endSceneX(driver);
2544                         endscenetime = timer.stop(true);
2545                 }
2546
2547                 drawtime = drawtimer.stop(true);
2548
2549                 /*
2550                         End of drawing
2551                 */
2552
2553                 static s16 lastFPS = 0;
2554                 //u16 fps = driver->getFPS();
2555                 u16 fps = (1.0/dtime_avg1);
2556
2557                 if (lastFPS != fps)
2558                 {
2559                         core::stringw str = L"Minetest [";
2560                         str += driver->getName();
2561                         str += "] FPS=";
2562                         str += fps;
2563
2564                         device->setWindowCaption(str.c_str());
2565                         lastFPS = fps;
2566                 }
2567         }
2568
2569         /*
2570                 Drop stuff
2571         */
2572         if(clouds)
2573                 clouds->drop();
2574         if(gui_chat_console)
2575                 gui_chat_console->drop();
2576
2577         /*
2578                 Draw a "shutting down" screen, which will be shown while the map
2579                 generator and other stuff quits
2580         */
2581         {
2582                 /*gui::IGUIStaticText *gui_shuttingdowntext = */
2583                 draw_load_screen(L"Shutting down stuff...", driver, font);
2584                 /*driver->beginScene(true, true, video::SColor(255,0,0,0));
2585                 guienv->drawAll();
2586                 driver->endScene();
2587                 gui_shuttingdowntext->remove();*/
2588         }
2589
2590         chat_backend.addMessage(L"", L"# Disconnected.");
2591         chat_backend.addMessage(L"", L"");
2592
2593         // Client scope (client is destructed before destructing *def and tsrc)
2594         }while(0);
2595
2596         delete tsrc;
2597         delete nodedef;
2598         delete itemdef;
2599 }
2600
2601