src/client/game.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2010-2013 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 Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser 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
  22 #include <iomanip>
  23 #include <cmath>
  24 #include "client/renderingengine.h"
  25 #include "camera.h"
  26 #include "client.h"
  27 #include "client/clientevent.h"
  28 #include "client/gameui.h"
  29 #include "client/inputhandler.h"
  30 #include "client/tile.h"     // For TextureSource
  31 #include "client/keys.h"
  32 #include "client/joystick_controller.h"
  33 #include "clientmap.h"
  34 #include "clouds.h"
  35 #include "config.h"
  36 #include "content_cao.h"
  37 #include "content/subgames.h"
  38 #include "client/event_manager.h"
  39 #include "fontengine.h"
  40 #include "itemdef.h"
  41 #include "log.h"
  42 #include "filesys.h"
  43 #include "gameparams.h"
  44 #include "gettext.h"
  45 #include "gui/guiChatConsole.h"
  46 #include "gui/guiFormSpecMenu.h"
  47 #include "gui/guiKeyChangeMenu.h"
  48 #include "gui/guiPasswordChange.h"
  49 #include "gui/guiVolumeChange.h"
  50 #include "gui/mainmenumanager.h"
  51 #include "gui/profilergraph.h"
  52 #include "mapblock.h"
  53 #include "minimap.h"
  54 #include "nodedef.h"         // Needed for determining pointing to nodes
  55 #include "nodemetadata.h"
  56 #include "particles.h"
  57 #include "porting.h"
  58 #include "profiler.h"
  59 #include "raycast.h"
  60 #include "server.h"
  61 #include "settings.h"
  62 #include "shader.h"
  63 #include "sky.h"
  64 #include "translation.h"
  65 #include "util/basic_macros.h"
  66 #include "util/directiontables.h"
  67 #include "util/pointedthing.h"
  68 #include "util/quicktune_shortcutter.h"
  69 #include "irrlicht_changes/static_text.h"
  70 #include "irr_ptr.h"
  71 #include "version.h"
  72 #include "script/scripting_client.h"
  73 #include "hud.h"
  74 #include "clientdynamicinfo.h"
  75
  76 #if USE_SOUND
  77         #include "client/sound_openal.h"
  78 #else
  79         #include "client/sound.h"
  80 #endif
  81 /*
  82         Text input system
  83 */
  84
  85 struct TextDestNodeMetadata : public TextDest
  86 {
  87         TextDestNodeMetadata(v3s16 p, Client *client)
  88         {
  89                 m_p = p;
  90                 m_client = client;
  91         }
  92         // This is deprecated I guess? -celeron55
  93         void gotText(const std::wstring &text)
  94         {
  95                 std::string ntext = wide_to_utf8(text);
  96                 infostream << "Submitting 'text' field of node at (" << m_p.X << ","
  97                            << m_p.Y << "," << m_p.Z << "): " << ntext << std::endl;
  98                 StringMap fields;
  99                 fields["text"] = ntext;
 100                 m_client->sendNodemetaFields(m_p, "", fields);
 101         }
 102         void gotText(const StringMap &fields)
 103         {
 104                 m_client->sendNodemetaFields(m_p, "", fields);
 105         }
 106
 107         v3s16 m_p;
 108         Client *m_client;
 109 };
 110
 111 struct TextDestPlayerInventory : public TextDest
 112 {
 113         TextDestPlayerInventory(Client *client)
 114         {
 115                 m_client = client;
 116                 m_formname.clear();
 117         }
 118         TextDestPlayerInventory(Client *client, const std::string &formname)
 119         {
 120                 m_client = client;
 121                 m_formname = formname;
 122         }
 123         void gotText(const StringMap &fields)
 124         {
 125                 m_client->sendInventoryFields(m_formname, fields);
 126         }
 127
 128         Client *m_client;
 129 };
 130
 131 struct LocalFormspecHandler : public TextDest
 132 {
 133         LocalFormspecHandler(const std::string &formname)
 134         {
 135                 m_formname = formname;
 136         }
 137
 138         LocalFormspecHandler(const std::string &formname, Client *client):
 139                 m_client(client)
 140         {
 141                 m_formname = formname;
 142         }
 143
 144         void gotText(const StringMap &fields)
 145         {
 146                 if (m_formname == "MT_PAUSE_MENU") {
 147                         if (fields.find("btn_sound") != fields.end()) {
 148                                 g_gamecallback->changeVolume();
 149                                 return;
 150                         }
 151
 152                         if (fields.find("btn_key_config") != fields.end()) {
 153                                 g_gamecallback->keyConfig();
 154                                 return;
 155                         }
 156
 157                         if (fields.find("btn_exit_menu") != fields.end()) {
 158                                 g_gamecallback->disconnect();
 159                                 return;
 160                         }
 161
 162                         if (fields.find("btn_exit_os") != fields.end()) {
 163                                 g_gamecallback->exitToOS();
 164 #ifndef __ANDROID__
 165                                 RenderingEngine::get_raw_device()->closeDevice();
 166 #endif
 167                                 return;
 168                         }
 169
 170                         if (fields.find("btn_change_password") != fields.end()) {
 171                                 g_gamecallback->changePassword();
 172                                 return;
 173                         }
 174
 175                         return;
 176                 }
 177
 178                 if (m_formname == "MT_DEATH_SCREEN") {
 179                         assert(m_client != 0);
 180                         m_client->sendRespawn();
 181                         return;
 182                 }
 183
 184                 if (m_client->modsLoaded())
 185                         m_client->getScript()->on_formspec_input(m_formname, fields);
 186         }
 187
 188         Client *m_client = nullptr;
 189 };
 190
 191 /* Form update callback */
 192
 193 class NodeMetadataFormSource: public IFormSource
 194 {
 195 public:
 196         NodeMetadataFormSource(ClientMap *map, v3s16 p):
 197                 m_map(map),
 198                 m_p(p)
 199         {
 200         }
 201         const std::string &getForm() const
 202         {
 203                 static const std::string empty_string = "";
 204                 NodeMetadata *meta = m_map->getNodeMetadata(m_p);
 205
 206                 if (!meta)
 207                         return empty_string;
 208
 209                 return meta->getString("formspec");
 210         }
 211
 212         virtual std::string resolveText(const std::string &str)
 213         {
 214                 NodeMetadata *meta = m_map->getNodeMetadata(m_p);
 215
 216                 if (!meta)
 217                         return str;
 218
 219                 return meta->resolveString(str);
 220         }
 221
 222         ClientMap *m_map;
 223         v3s16 m_p;
 224 };
 225
 226 class PlayerInventoryFormSource: public IFormSource
 227 {
 228 public:
 229         PlayerInventoryFormSource(Client *client):
 230                 m_client(client)
 231         {
 232         }
 233
 234         const std::string &getForm() const
 235         {
 236                 LocalPlayer *player = m_client->getEnv().getLocalPlayer();
 237                 return player->inventory_formspec;
 238         }
 239
 240         Client *m_client;
 241 };
 242
 243 class NodeDugEvent : public MtEvent
 244 {
 245 public:
 246         v3s16 p;
 247         MapNode n;
 248
 249         NodeDugEvent(v3s16 p, MapNode n):
 250                 p(p),
 251                 n(n)
 252         {}
 253         Type getType() const { return NODE_DUG; }
 254 };
 255
 256 class SoundMaker
 257 {
 258         ISoundManager *m_sound;
 259         const NodeDefManager *m_ndef;
 260
 261 public:
 262         bool makes_footstep_sound;
 263         float m_player_step_timer;
 264         float m_player_jump_timer;
 265
 266         SimpleSoundSpec m_player_step_sound;
 267         SimpleSoundSpec m_player_leftpunch_sound;
 268         // Second sound made on left punch, currently used for item 'use' sound
 269         SimpleSoundSpec m_player_leftpunch_sound2;
 270         SimpleSoundSpec m_player_rightpunch_sound;
 271
 272         SoundMaker(ISoundManager *sound, const NodeDefManager *ndef):
 273                 m_sound(sound),
 274                 m_ndef(ndef),
 275                 makes_footstep_sound(true),
 276                 m_player_step_timer(0.0f),
 277                 m_player_jump_timer(0.0f)
 278         {
 279         }
 280
 281         void playPlayerStep()
 282         {
 283                 if (m_player_step_timer <= 0 && m_player_step_sound.exists()) {
 284                         m_player_step_timer = 0.03;
 285                         if (makes_footstep_sound)
 286                                 m_sound->playSound(m_player_step_sound);
 287                 }
 288         }
 289
 290         void playPlayerJump()
 291         {
 292                 if (m_player_jump_timer <= 0.0f) {
 293                         m_player_jump_timer = 0.2f;
 294                         m_sound->playSound(SimpleSoundSpec("player_jump", 0.5f));
 295                 }
 296         }
 297
 298         static void viewBobbingStep(MtEvent *e, void *data)
 299         {
 300                 SoundMaker *sm = (SoundMaker *)data;
 301                 sm->playPlayerStep();
 302         }
 303
 304         static void playerRegainGround(MtEvent *e, void *data)
 305         {
 306                 SoundMaker *sm = (SoundMaker *)data;
 307                 sm->playPlayerStep();
 308         }
 309
 310         static void playerJump(MtEvent *e, void *data)
 311         {
 312                 SoundMaker *sm = (SoundMaker *)data;
 313                 sm->playPlayerJump();
 314         }
 315
 316         static void cameraPunchLeft(MtEvent *e, void *data)
 317         {
 318                 SoundMaker *sm = (SoundMaker *)data;
 319                 sm->m_sound->playSound(sm->m_player_leftpunch_sound);
 320                 sm->m_sound->playSound(sm->m_player_leftpunch_sound2);
 321         }
 322
 323         static void cameraPunchRight(MtEvent *e, void *data)
 324         {
 325                 SoundMaker *sm = (SoundMaker *)data;
 326                 sm->m_sound->playSound(sm->m_player_rightpunch_sound);
 327         }
 328
 329         static void nodeDug(MtEvent *e, void *data)
 330         {
 331                 SoundMaker *sm = (SoundMaker *)data;
 332                 NodeDugEvent *nde = (NodeDugEvent *)e;
 333                 sm->m_sound->playSound(sm->m_ndef->get(nde->n).sound_dug);
 334         }
 335
 336         static void playerDamage(MtEvent *e, void *data)
 337         {
 338                 SoundMaker *sm = (SoundMaker *)data;
 339                 sm->m_sound->playSound(SimpleSoundSpec("player_damage", 0.5));
 340         }
 341
 342         static void playerFallingDamage(MtEvent *e, void *data)
 343         {
 344                 SoundMaker *sm = (SoundMaker *)data;
 345                 sm->m_sound->playSound(SimpleSoundSpec("player_falling_damage", 0.5));
 346         }
 347
 348         void registerReceiver(MtEventManager *mgr)
 349         {
 350                 mgr->reg(MtEvent::VIEW_BOBBING_STEP, SoundMaker::viewBobbingStep, this);
 351                 mgr->reg(MtEvent::PLAYER_REGAIN_GROUND, SoundMaker::playerRegainGround, this);
 352                 mgr->reg(MtEvent::PLAYER_JUMP, SoundMaker::playerJump, this);
 353                 mgr->reg(MtEvent::CAMERA_PUNCH_LEFT, SoundMaker::cameraPunchLeft, this);
 354                 mgr->reg(MtEvent::CAMERA_PUNCH_RIGHT, SoundMaker::cameraPunchRight, this);
 355                 mgr->reg(MtEvent::NODE_DUG, SoundMaker::nodeDug, this);
 356                 mgr->reg(MtEvent::PLAYER_DAMAGE, SoundMaker::playerDamage, this);
 357                 mgr->reg(MtEvent::PLAYER_FALLING_DAMAGE, SoundMaker::playerFallingDamage, this);
 358         }
 359
 360         void step(float dtime)
 361         {
 362                 m_player_step_timer -= dtime;
 363                 m_player_jump_timer -= dtime;
 364         }
 365 };
 366
 367 // Locally stored sounds don't need to be preloaded because of this
 368 class GameOnDemandSoundFetcher: public OnDemandSoundFetcher
 369 {
 370         std::set<std::string> m_fetched;
 371 private:
 372         void paths_insert(std::set<std::string> &dst_paths,
 373                 const std::string &base,
 374                 const std::string &name)
 375         {
 376                 dst_paths.insert(base + DIR_DELIM + "sounds" + DIR_DELIM + name + ".ogg");
 377                 dst_paths.insert(base + DIR_DELIM + "sounds" + DIR_DELIM + name + ".0.ogg");
 378                 dst_paths.insert(base + DIR_DELIM + "sounds" + DIR_DELIM + name + ".1.ogg");
 379                 dst_paths.insert(base + DIR_DELIM + "sounds" + DIR_DELIM + name + ".2.ogg");
 380                 dst_paths.insert(base + DIR_DELIM + "sounds" + DIR_DELIM + name + ".3.ogg");
 381                 dst_paths.insert(base + DIR_DELIM + "sounds" + DIR_DELIM + name + ".4.ogg");
 382                 dst_paths.insert(base + DIR_DELIM + "sounds" + DIR_DELIM + name + ".5.ogg");
 383                 dst_paths.insert(base + DIR_DELIM + "sounds" + DIR_DELIM + name + ".6.ogg");
 384                 dst_paths.insert(base + DIR_DELIM + "sounds" + DIR_DELIM + name + ".7.ogg");
 385                 dst_paths.insert(base + DIR_DELIM + "sounds" + DIR_DELIM + name + ".8.ogg");
 386                 dst_paths.insert(base + DIR_DELIM + "sounds" + DIR_DELIM + name + ".9.ogg");
 387         }
 388 public:
 389         void fetchSounds(const std::string &name,
 390                 std::set<std::string> &dst_paths,
 391                 std::set<std::string> &dst_datas)
 392         {
 393                 if (m_fetched.count(name))
 394                         return;
 395
 396                 m_fetched.insert(name);
 397
 398                 paths_insert(dst_paths, porting::path_share, name);
 399                 paths_insert(dst_paths, porting::path_user,  name);
 400         }
 401 };
 402
 403
 404 typedef s32 SamplerLayer_t;
 405
 406
 407 class GameGlobalShaderConstantSetter : public IShaderConstantSetter
 408 {
 409         Sky *m_sky;
 410         Client *m_client;
 411         bool *m_force_fog_off;
 412         f32 *m_fog_range;
 413         bool m_fog_enabled;
 414         CachedPixelShaderSetting<float, 4> m_sky_bg_color;
 415         CachedPixelShaderSetting<float> m_fog_distance;
 416         CachedVertexShaderSetting<float> m_animation_timer_vertex;
 417         CachedPixelShaderSetting<float> m_animation_timer_pixel;
 418         CachedVertexShaderSetting<float> m_animation_timer_delta_vertex;
 419         CachedPixelShaderSetting<float> m_animation_timer_delta_pixel;
 420         CachedPixelShaderSetting<float, 3> m_day_light;
 421         CachedPixelShaderSetting<float, 4> m_star_color;
 422         CachedPixelShaderSetting<float, 3> m_eye_position_pixel;
 423         CachedVertexShaderSetting<float, 3> m_eye_position_vertex;
 424         CachedPixelShaderSetting<float, 3> m_minimap_yaw;
 425         CachedPixelShaderSetting<float, 3> m_camera_offset_pixel;
 426         CachedPixelShaderSetting<float, 3> m_camera_offset_vertex;
 427         CachedPixelShaderSetting<SamplerLayer_t> m_texture0;
 428         CachedPixelShaderSetting<SamplerLayer_t> m_texture1;
 429         CachedPixelShaderSetting<SamplerLayer_t> m_texture2;
 430         CachedPixelShaderSetting<SamplerLayer_t> m_texture3;
 431         CachedPixelShaderSetting<float, 2> m_texel_size0;
 432         std::array<float, 2> m_texel_size0_values;
 433         CachedStructPixelShaderSetting<float, 7> m_exposure_params_pixel;
 434         float m_user_exposure_compensation;
 435         bool m_bloom_enabled;
 436         CachedPixelShaderSetting<float> m_bloom_intensity_pixel;
 437         float m_bloom_intensity;
 438         CachedPixelShaderSetting<float> m_bloom_strength_pixel;
 439         float m_bloom_strength;
 440         CachedPixelShaderSetting<float> m_bloom_radius_pixel;
 441         float m_bloom_radius;
 442         CachedPixelShaderSetting<float> m_saturation_pixel;
 443
 444 public:
 445         void onSettingsChange(const std::string &name)
 446         {
 447                 if (name == "enable_fog")
 448                         m_fog_enabled = g_settings->getBool("enable_fog");
 449                 if (name == "exposure_compensation")
 450                         m_user_exposure_compensation = g_settings->getFloat("exposure_compensation", -1.0f, 1.0f);
 451                 if (name == "bloom_intensity")
 452                         m_bloom_intensity = g_settings->getFloat("bloom_intensity", 0.01f, 1.0f);
 453                 if (name == "bloom_strength_factor")
 454                         m_bloom_strength = RenderingEngine::BASE_BLOOM_STRENGTH * g_settings->getFloat("bloom_strength_factor", 0.1f, 10.0f);
 455                 if (name == "bloom_radius")
 456                         m_bloom_radius = g_settings->getFloat("bloom_radius", 0.1f, 8.0f);
 457         }
 458
 459         static void settingsCallback(const std::string &name, void *userdata)
 460         {
 461                 reinterpret_cast<GameGlobalShaderConstantSetter*>(userdata)->onSettingsChange(name);
 462         }
 463
 464         void setSky(Sky *sky) { m_sky = sky; }
 465
 466         GameGlobalShaderConstantSetter(Sky *sky, bool *force_fog_off,
 467                         f32 *fog_range, Client *client) :
 468                 m_sky(sky),
 469                 m_client(client),
 470                 m_force_fog_off(force_fog_off),
 471                 m_fog_range(fog_range),
 472                 m_sky_bg_color("skyBgColor"),
 473                 m_fog_distance("fogDistance"),
 474                 m_animation_timer_vertex("animationTimer"),
 475                 m_animation_timer_pixel("animationTimer"),
 476                 m_animation_timer_delta_vertex("animationTimerDelta"),
 477                 m_animation_timer_delta_pixel("animationTimerDelta"),
 478                 m_day_light("dayLight"),
 479                 m_star_color("starColor"),
 480                 m_eye_position_pixel("eyePosition"),
 481                 m_eye_position_vertex("eyePosition"),
 482                 m_minimap_yaw("yawVec"),
 483                 m_camera_offset_pixel("cameraOffset"),
 484                 m_camera_offset_vertex("cameraOffset"),
 485                 m_texture0("texture0"),
 486                 m_texture1("texture1"),
 487                 m_texture2("texture2"),
 488                 m_texture3("texture3"),
 489                 m_texel_size0("texelSize0"),
 490                 m_exposure_params_pixel("exposureParams",
 491                                 std::array<const char*, 7> {
 492                                                 "luminanceMin", "luminanceMax", "exposureCorrection",
 493                                                 "speedDarkBright", "speedBrightDark", "centerWeightPower", "compensationFactor"
 494                                 }),
 495                 m_bloom_intensity_pixel("bloomIntensity"),
 496                 m_bloom_strength_pixel("bloomStrength"),
 497                 m_bloom_radius_pixel("bloomRadius"),
 498                 m_saturation_pixel("saturation")
 499         {
 500                 g_settings->registerChangedCallback("enable_fog", settingsCallback, this);
 501                 g_settings->registerChangedCallback("exposure_compensation", settingsCallback, this);
 502                 g_settings->registerChangedCallback("bloom_intensity", settingsCallback, this);
 503                 g_settings->registerChangedCallback("bloom_strength_factor", settingsCallback, this);
 504                 g_settings->registerChangedCallback("bloom_radius", settingsCallback, this);
 505                 g_settings->registerChangedCallback("saturation", settingsCallback, this);
 506                 m_fog_enabled = g_settings->getBool("enable_fog");
 507                 m_user_exposure_compensation = g_settings->getFloat("exposure_compensation", -1.0f, 1.0f);
 508                 m_bloom_enabled = g_settings->getBool("enable_bloom");
 509                 m_bloom_intensity = g_settings->getFloat("bloom_intensity", 0.01f, 1.0f);
 510                 m_bloom_strength = RenderingEngine::BASE_BLOOM_STRENGTH * g_settings->getFloat("bloom_strength_factor", 0.1f, 10.0f);
 511                 m_bloom_radius = g_settings->getFloat("bloom_radius", 0.1f, 8.0f);
 512         }
 513
 514         ~GameGlobalShaderConstantSetter()
 515         {
 516                 g_settings->deregisterChangedCallback("enable_fog", settingsCallback, this);
 517         }
 518
 519         void onSetConstants(video::IMaterialRendererServices *services) override
 520         {
 521                 // Background color
 522                 video::SColor bgcolor = m_sky->getBgColor();
 523                 video::SColorf bgcolorf(bgcolor);
 524                 float bgcolorfa[4] = {
 525                         bgcolorf.r,
 526                         bgcolorf.g,
 527                         bgcolorf.b,
 528                         bgcolorf.a,
 529                 };
 530                 m_sky_bg_color.set(bgcolorfa, services);
 531
 532                 // Fog distance
 533                 float fog_distance = 10000 * BS;
 534
 535                 if (m_fog_enabled && !*m_force_fog_off)
 536                         fog_distance = *m_fog_range;
 537
 538                 m_fog_distance.set(&fog_distance, services);
 539
 540                 u32 daynight_ratio = (float)m_client->getEnv().getDayNightRatio();
 541                 video::SColorf sunlight;
 542                 get_sunlight_color(&sunlight, daynight_ratio);
 543                 float dnc[3] = {
 544                         sunlight.r,
 545                         sunlight.g,
 546                         sunlight.b };
 547                 m_day_light.set(dnc, services);
 548
 549                 video::SColorf star_color = m_sky->getCurrentStarColor();
 550                 float clr[4] = {star_color.r, star_color.g, star_color.b, star_color.a};
 551                 m_star_color.set(clr, services);
 552
 553                 u32 animation_timer = m_client->getEnv().getFrameTime() % 1000000;
 554                 float animation_timer_f = (float)animation_timer / 100000.f;
 555                 m_animation_timer_vertex.set(&animation_timer_f, services);
 556                 m_animation_timer_pixel.set(&animation_timer_f, services);
 557
 558                 float animation_timer_delta_f = (float)m_client->getEnv().getFrameTimeDelta() / 100000.f;
 559                 m_animation_timer_delta_vertex.set(&animation_timer_delta_f, services);
 560                 m_animation_timer_delta_pixel.set(&animation_timer_delta_f, services);
 561
 562                 float eye_position_array[3];
 563                 v3f epos = m_client->getEnv().getLocalPlayer()->getEyePosition();
 564                 epos.getAs3Values(eye_position_array);
 565                 m_eye_position_pixel.set(eye_position_array, services);
 566                 m_eye_position_vertex.set(eye_position_array, services);
 567
 568                 if (m_client->getMinimap()) {
 569                         float minimap_yaw_array[3];
 570                         v3f minimap_yaw = m_client->getMinimap()->getYawVec();
 571                         minimap_yaw.getAs3Values(minimap_yaw_array);
 572                         m_minimap_yaw.set(minimap_yaw_array, services);
 573                 }
 574
 575                 float camera_offset_array[3];
 576                 v3f offset = intToFloat(m_client->getCamera()->getOffset(), BS);
 577                 offset.getAs3Values(camera_offset_array);
 578                 m_camera_offset_pixel.set(camera_offset_array, services);
 579                 m_camera_offset_vertex.set(camera_offset_array, services);
 580
 581                 SamplerLayer_t tex_id;
 582                 tex_id = 0;
 583                 m_texture0.set(&tex_id, services);
 584                 tex_id = 1;
 585                 m_texture1.set(&tex_id, services);
 586                 tex_id = 2;
 587                 m_texture2.set(&tex_id, services);
 588                 tex_id = 3;
 589                 m_texture3.set(&tex_id, services);
 590
 591                 m_texel_size0.set(m_texel_size0_values.data(), services);
 592
 593                 const AutoExposure &exposure_params = m_client->getEnv().getLocalPlayer()->getLighting().exposure;
 594                 std::array<float, 7> exposure_buffer = {
 595                         std::pow(2.0f, exposure_params.luminance_min),
 596                         std::pow(2.0f, exposure_params.luminance_max),
 597                         exposure_params.exposure_correction,
 598                         exposure_params.speed_dark_bright,
 599                         exposure_params.speed_bright_dark,
 600                         exposure_params.center_weight_power,
 601                         powf(2.f, m_user_exposure_compensation)
 602                 };
 603                 m_exposure_params_pixel.set(exposure_buffer.data(), services);
 604
 605                 if (m_bloom_enabled) {
 606                         m_bloom_intensity_pixel.set(&m_bloom_intensity, services);
 607                         m_bloom_radius_pixel.set(&m_bloom_radius, services);
 608                         m_bloom_strength_pixel.set(&m_bloom_strength, services);
 609                 }
 610                 float saturation = m_client->getEnv().getLocalPlayer()->getLighting().saturation;
 611                 m_saturation_pixel.set(&saturation, services);
 612         }
 613
 614         void onSetMaterial(const video::SMaterial &material)
 615         {
 616                 video::ITexture *texture = material.getTexture(0);
 617                 if (texture) {
 618                         core::dimension2du size = texture->getSize();
 619                         m_texel_size0_values[0] = 1.f / size.Width;
 620                         m_texel_size0_values[1] = 1.f / size.Height;
 621                 }
 622                 else {
 623                         m_texel_size0_values[0] = 0.f;
 624                         m_texel_size0_values[1] = 0.f;
 625                 }
 626         }
 627 };
 628
 629
 630 class GameGlobalShaderConstantSetterFactory : public IShaderConstantSetterFactory
 631 {
 632         Sky *m_sky;
 633         bool *m_force_fog_off;
 634         f32 *m_fog_range;
 635         Client *m_client;
 636         std::vector<GameGlobalShaderConstantSetter *> created_nosky;
 637 public:
 638         GameGlobalShaderConstantSetterFactory(bool *force_fog_off,
 639                         f32 *fog_range, Client *client) :
 640                 m_sky(NULL),
 641                 m_force_fog_off(force_fog_off),
 642                 m_fog_range(fog_range),
 643                 m_client(client)
 644         {}
 645
 646         void setSky(Sky *sky) {
 647                 m_sky = sky;
 648                 for (GameGlobalShaderConstantSetter *ggscs : created_nosky) {
 649                         ggscs->setSky(m_sky);
 650                 }
 651                 created_nosky.clear();
 652         }
 653
 654         virtual IShaderConstantSetter* create()
 655         {
 656                 auto *scs = new GameGlobalShaderConstantSetter(
 657                                 m_sky, m_force_fog_off, m_fog_range, m_client);
 658                 if (!m_sky)
 659                         created_nosky.push_back(scs);
 660                 return scs;
 661         }
 662 };
 663
 664 #ifdef HAVE_TOUCHSCREENGUI
 665 #define SIZE_TAG "size[11,5.5]"
 666 #else
 667 #define SIZE_TAG "size[11,5.5,true]" // Fixed size on desktop
 668 #endif
 669
 670 /****************************************************************************
 671  ****************************************************************************/
 672
 673 const static float object_hit_delay = 0.2;
 674
 675 struct FpsControl {
 676         FpsControl() : last_time(0), busy_time(0), sleep_time(0) {}
 677
 678         void reset();
 679
 680         void limit(IrrlichtDevice *device, f32 *dtime);
 681
 682         u32 getBusyMs() const { return busy_time / 1000; }
 683
 684         // all values in microseconds (us)
 685         u64 last_time, busy_time, sleep_time;
 686 };
 687
 688
 689 /* The reason the following structs are not anonymous structs within the
 690  * class is that they are not used by the majority of member functions and
 691  * many functions that do require objects of thse types do not modify them
 692  * (so they can be passed as a const qualified parameter)
 693  */
 694
 695 struct GameRunData {
 696         u16 dig_index;
 697         u16 new_playeritem;
 698         PointedThing pointed_old;
 699         bool digging;
 700         bool punching;
 701         bool btn_down_for_dig;
 702         bool dig_instantly;
 703         bool digging_blocked;
 704         bool reset_jump_timer;
 705         float nodig_delay_timer;
 706         float dig_time;
 707         float dig_time_complete;
 708         float repeat_place_timer;
 709         float object_hit_delay_timer;
 710         float time_from_last_punch;
 711         ClientActiveObject *selected_object;
 712
 713         float jump_timer_up;          // from key up until key down
 714         float jump_timer_down;        // since last key down
 715         float jump_timer_down_before; // from key down until key down again
 716
 717         float damage_flash;
 718         float update_draw_list_timer;
 719         float touch_blocks_timer;
 720
 721         f32 fog_range;
 722
 723         v3f update_draw_list_last_cam_dir;
 724
 725         float time_of_day_smooth;
 726 };
 727
 728 class Game;
 729
 730 struct ClientEventHandler
 731 {
 732         void (Game::*handler)(ClientEvent *, CameraOrientation *);
 733 };
 734
 735 /****************************************************************************
 736  THE GAME
 737  ****************************************************************************/
 738
 739 using PausedNodesList = std::vector<std::pair<irr_ptr<scene::IAnimatedMeshSceneNode>, float>>;
 740
 741 /* This is not intended to be a public class. If a public class becomes
 742  * desirable then it may be better to create another 'wrapper' class that
 743  * hides most of the stuff in this class (nothing in this class is required
 744  * by any other file) but exposes the public methods/data only.
 745  */
 746 class Game {
 747 public:
 748         Game();
 749         ~Game();
 750
 751         bool startup(bool *kill,
 752                         InputHandler *input,
 753                         RenderingEngine *rendering_engine,
 754                         const GameStartData &game_params,
 755                         std::string &error_message,
 756                         bool *reconnect,
 757                         ChatBackend *chat_backend);
 758
 759         void run();
 760         void shutdown();
 761
 762 protected:
 763
 764         // Basic initialisation
 765         bool init(const std::string &map_dir, const std::string &address,
 766                         u16 port, const SubgameSpec &gamespec);
 767         bool initSound();
 768         bool createSingleplayerServer(const std::string &map_dir,
 769                         const SubgameSpec &gamespec, u16 port);
 770
 771         // Client creation
 772         bool createClient(const GameStartData &start_data);
 773         bool initGui();
 774
 775         // Client connection
 776         bool connectToServer(const GameStartData &start_data,
 777                         bool *connect_ok, bool *aborted);
 778         bool getServerContent(bool *aborted);
 779
 780         // Main loop
 781
 782         void updateInteractTimers(f32 dtime);
 783         bool checkConnection();
 784         bool handleCallbacks();
 785         void processQueues();
 786         void updateProfilers(const RunStats &stats, const FpsControl &draw_times, f32 dtime);
 787         void updateDebugState();
 788         void updateStats(RunStats *stats, const FpsControl &draw_times, f32 dtime);
 789         void updateProfilerGraphs(ProfilerGraph *graph);
 790
 791         // Input related
 792         void processUserInput(f32 dtime);
 793         void processKeyInput();
 794         void processItemSelection(u16 *new_playeritem);
 795
 796         void dropSelectedItem(bool single_item = false);
 797         void openInventory();
 798         void openConsole(float scale, const wchar_t *line=NULL);
 799         void toggleFreeMove();
 800         void toggleFreeMoveAlt();
 801         void togglePitchMove();
 802         void toggleFast();
 803         void toggleNoClip();
 804         void toggleCinematic();
 805         void toggleBlockBounds();
 806         void toggleAutoforward();
 807
 808         void toggleMinimap(bool shift_pressed);
 809         void toggleFog();
 810         void toggleDebug();
 811         void toggleUpdateCamera();
 812
 813         void increaseViewRange();
 814         void decreaseViewRange();
 815         void toggleFullViewRange();
 816         void checkZoomEnabled();
 817
 818         void updateCameraDirection(CameraOrientation *cam, float dtime);
 819         void updateCameraOrientation(CameraOrientation *cam, float dtime);
 820         void updatePlayerControl(const CameraOrientation &cam);
 821         void step(f32 dtime);
 822         void processClientEvents(CameraOrientation *cam);
 823         void updateCamera(f32 dtime);
 824         void updateSound(f32 dtime);
 825         void processPlayerInteraction(f32 dtime, bool show_hud);
 826         /*!
 827          * Returns the object or node the player is pointing at.
 828          * Also updates the selected thing in the Hud.
 829          *
 830          * @param[in]  shootline         the shootline, starting from
 831          * the camera position. This also gives the maximal distance
 832          * of the search.
 833          * @param[in]  liquids_pointable if false, liquids are ignored
 834          * @param[in]  look_for_object   if false, objects are ignored
 835          * @param[in]  camera_offset     offset of the camera
 836          * @param[out] selected_object   the selected object or
 837          * NULL if not found
 838          */
 839         PointedThing updatePointedThing(
 840                         const core::line3d<f32> &shootline, bool liquids_pointable,
 841                         bool look_for_object, const v3s16 &camera_offset);
 842         void handlePointingAtNothing(const ItemStack &playerItem);
 843         void handlePointingAtNode(const PointedThing &pointed,
 844                         const ItemStack &selected_item, const ItemStack &hand_item, f32 dtime);
 845         void handlePointingAtObject(const PointedThing &pointed, const ItemStack &playeritem,
 846                         const v3f &player_position, bool show_debug);
 847         void handleDigging(const PointedThing &pointed, const v3s16 &nodepos,
 848                         const ItemStack &selected_item, const ItemStack &hand_item, f32 dtime);
 849         void updateFrame(ProfilerGraph *graph, RunStats *stats, f32 dtime,
 850                         const CameraOrientation &cam);
 851         void updateShadows();
 852
 853         // Misc
 854         void showOverlayMessage(const char *msg, float dtime, int percent,
 855                         bool draw_clouds = true);
 856
 857         static void settingChangedCallback(const std::string &setting_name, void *data);
 858         void readSettings();
 859
 860         inline bool isKeyDown(GameKeyType k)
 861         {
 862                 return input->isKeyDown(k);
 863         }
 864         inline bool wasKeyDown(GameKeyType k)
 865         {
 866                 return input->wasKeyDown(k);
 867         }
 868         inline bool wasKeyPressed(GameKeyType k)
 869         {
 870                 return input->wasKeyPressed(k);
 871         }
 872         inline bool wasKeyReleased(GameKeyType k)
 873         {
 874                 return input->wasKeyReleased(k);
 875         }
 876
 877 #ifdef __ANDROID__
 878         void handleAndroidChatInput();
 879 #endif
 880
 881 private:
 882         struct Flags {
 883                 bool force_fog_off = false;
 884                 bool disable_camera_update = false;
 885         };
 886
 887         void showDeathFormspec();
 888         void showPauseMenu();
 889
 890         void pauseAnimation();
 891         void resumeAnimation();
 892
 893         // ClientEvent handlers
 894         void handleClientEvent_None(ClientEvent *event, CameraOrientation *cam);
 895         void handleClientEvent_PlayerDamage(ClientEvent *event, CameraOrientation *cam);
 896         void handleClientEvent_PlayerForceMove(ClientEvent *event, CameraOrientation *cam);
 897         void handleClientEvent_Deathscreen(ClientEvent *event, CameraOrientation *cam);
 898         void handleClientEvent_ShowFormSpec(ClientEvent *event, CameraOrientation *cam);
 899         void handleClientEvent_ShowLocalFormSpec(ClientEvent *event, CameraOrientation *cam);
 900         void handleClientEvent_HandleParticleEvent(ClientEvent *event,
 901                 CameraOrientation *cam);
 902         void handleClientEvent_HudAdd(ClientEvent *event, CameraOrientation *cam);
 903         void handleClientEvent_HudRemove(ClientEvent *event, CameraOrientation *cam);
 904         void handleClientEvent_HudChange(ClientEvent *event, CameraOrientation *cam);
 905         void handleClientEvent_SetSky(ClientEvent *event, CameraOrientation *cam);
 906         void handleClientEvent_SetSun(ClientEvent *event, CameraOrientation *cam);
 907         void handleClientEvent_SetMoon(ClientEvent *event, CameraOrientation *cam);
 908         void handleClientEvent_SetStars(ClientEvent *event, CameraOrientation *cam);
 909         void handleClientEvent_OverrideDayNigthRatio(ClientEvent *event,
 910                 CameraOrientation *cam);
 911         void handleClientEvent_CloudParams(ClientEvent *event, CameraOrientation *cam);
 912
 913         void updateChat(f32 dtime);
 914
 915         bool nodePlacement(const ItemDefinition &selected_def, const ItemStack &selected_item,
 916                 const v3s16 &nodepos, const v3s16 &neighborpos, const PointedThing &pointed,
 917                 const NodeMetadata *meta);
 918         static const ClientEventHandler clientEventHandler[CLIENTEVENT_MAX];
 919
 920         f32 getSensitivityScaleFactor() const;
 921         ClientDynamicInfo getCurrentDynamicInfo() const;
 922
 923         InputHandler *input = nullptr;
 924
 925         Client *client = nullptr;
 926         Server *server = nullptr;
 927
 928         ClientDynamicInfo client_display_info{};
 929         float dynamic_info_send_timer = 0;
 930
 931         IWritableTextureSource *texture_src = nullptr;
 932         IWritableShaderSource *shader_src = nullptr;
 933
 934         // When created, these will be filled with data received from the server
 935         IWritableItemDefManager *itemdef_manager = nullptr;
 936         NodeDefManager *nodedef_manager = nullptr;
 937
 938         GameOnDemandSoundFetcher soundfetcher; // useful when testing
 939         ISoundManager *sound = nullptr;
 940         bool sound_is_dummy = false;
 941         SoundMaker *soundmaker = nullptr;
 942
 943         ChatBackend *chat_backend = nullptr;
 944         LogOutputBuffer m_chat_log_buf;
 945
 946         EventManager *eventmgr = nullptr;
 947         QuicktuneShortcutter *quicktune = nullptr;
 948
 949         std::unique_ptr<GameUI> m_game_ui;
 950         GUIChatConsole *gui_chat_console = nullptr; // Free using ->Drop()
 951         MapDrawControl *draw_control = nullptr;
 952         Camera *camera = nullptr;
 953         Clouds *clouds = nullptr;                         // Free using ->Drop()
 954         Sky *sky = nullptr;                         // Free using ->Drop()
 955         Hud *hud = nullptr;
 956         Minimap *mapper = nullptr;
 957
 958         // Map server hud ids to client hud ids
 959         std::unordered_map<u32, u32> m_hud_server_to_client;
 960
 961         GameRunData runData;
 962         Flags m_flags;
 963
 964         /* 'cache'
 965            This class does take ownership/responsibily for cleaning up etc of any of
 966            these items (e.g. device)
 967         */
 968         IrrlichtDevice *device;
 969         RenderingEngine *m_rendering_engine;
 970         video::IVideoDriver *driver;
 971         scene::ISceneManager *smgr;
 972         bool *kill;
 973         std::string *error_message;
 974         bool *reconnect_requested;
 975         scene::ISceneNode *skybox;
 976         PausedNodesList paused_animated_nodes;
 977
 978         bool simple_singleplayer_mode;
 979         /* End 'cache' */
 980
 981         /* Pre-calculated values
 982          */
 983         int crack_animation_length;
 984
 985         IntervalLimiter profiler_interval;
 986
 987         /*
 988          * TODO: Local caching of settings is not optimal and should at some stage
 989          *       be updated to use a global settings object for getting thse values
 990          *       (as opposed to the this local caching). This can be addressed in
 991          *       a later release.
 992          */
 993         bool m_cache_doubletap_jump;
 994         bool m_cache_enable_clouds;
 995         bool m_cache_enable_joysticks;
 996         bool m_cache_enable_particles;
 997         bool m_cache_enable_fog;
 998         bool m_cache_enable_noclip;
 999         bool m_cache_enable_free_move;
1000         f32  m_cache_mouse_sensitivity;
1001         f32  m_cache_joystick_frustum_sensitivity;
1002         f32  m_repeat_place_time;
1003         f32  m_cache_cam_smoothing;
1004         f32  m_cache_fog_start;
1005
1006         bool m_invert_mouse = false;
1007         bool m_first_loop_after_window_activation = false;
1008         bool m_camera_offset_changed = false;
1009
1010         bool m_does_lost_focus_pause_game = false;
1011
1012         // if true, (almost) the whole game is paused
1013         // this happens in pause menu in singleplayer
1014         bool m_is_paused = false;
1015
1016 #ifdef HAVE_TOUCHSCREENGUI
1017         bool m_cache_hold_aux1;
1018         bool m_touch_use_crosshair;
1019         inline bool isNoCrosshairAllowed() {
1020                 return !m_touch_use_crosshair && camera->getCameraMode() == CAMERA_MODE_FIRST;
1021         }
1022 #endif
1023 #ifdef __ANDROID__
1024         bool m_android_chat_open;
1025 #endif
1026 };
1027
1028 Game::Game() :
1029         m_chat_log_buf(g_logger),
1030         m_game_ui(new GameUI())
1031 {
1032         g_settings->registerChangedCallback("doubletap_jump",
1033                 &settingChangedCallback, this);
1034         g_settings->registerChangedCallback("enable_clouds",
1035                 &settingChangedCallback, this);
1036         g_settings->registerChangedCallback("doubletap_joysticks",
1037                 &settingChangedCallback, this);
1038         g_settings->registerChangedCallback("enable_particles",
1039                 &settingChangedCallback, this);
1040         g_settings->registerChangedCallback("enable_fog",
1041                 &settingChangedCallback, this);
1042         g_settings->registerChangedCallback("mouse_sensitivity",
1043                 &settingChangedCallback, this);
1044         g_settings->registerChangedCallback("joystick_frustum_sensitivity",
1045                 &settingChangedCallback, this);
1046         g_settings->registerChangedCallback("repeat_place_time",
1047                 &settingChangedCallback, this);
1048         g_settings->registerChangedCallback("noclip",
1049                 &settingChangedCallback, this);
1050         g_settings->registerChangedCallback("free_move",
1051                 &settingChangedCallback, this);
1052         g_settings->registerChangedCallback("cinematic",
1053                 &settingChangedCallback, this);
1054         g_settings->registerChangedCallback("cinematic_camera_smoothing",
1055                 &settingChangedCallback, this);
1056         g_settings->registerChangedCallback("camera_smoothing",
1057                 &settingChangedCallback, this);
1058
1059         readSettings();
1060
1061 #ifdef HAVE_TOUCHSCREENGUI
1062         m_cache_hold_aux1 = false;      // This is initialised properly later
1063 #endif
1064
1065 }
1066
1067
1068
1069 /****************************************************************************
1070  MinetestApp Public
1071  ****************************************************************************/
1072
1073 Game::~Game()
1074 {
1075         delete client;
1076         delete soundmaker;
1077         if (!sound_is_dummy)
1078                 delete sound;
1079
1080         delete server; // deleted first to stop all server threads
1081
1082         delete hud;
1083         delete camera;
1084         delete quicktune;
1085         delete eventmgr;
1086         delete texture_src;
1087         delete shader_src;
1088         delete nodedef_manager;
1089         delete itemdef_manager;
1090         delete draw_control;
1091
1092         clearTextureNameCache();
1093
1094         g_settings->deregisterChangedCallback("doubletap_jump",
1095                 &settingChangedCallback, this);
1096         g_settings->deregisterChangedCallback("enable_clouds",
1097                 &settingChangedCallback, this);
1098         g_settings->deregisterChangedCallback("enable_particles",
1099                 &settingChangedCallback, this);
1100         g_settings->deregisterChangedCallback("enable_fog",
1101                 &settingChangedCallback, this);
1102         g_settings->deregisterChangedCallback("mouse_sensitivity",
1103                 &settingChangedCallback, this);
1104         g_settings->deregisterChangedCallback("repeat_place_time",
1105                 &settingChangedCallback, this);
1106         g_settings->deregisterChangedCallback("noclip",
1107                 &settingChangedCallback, this);
1108         g_settings->deregisterChangedCallback("free_move",
1109                 &settingChangedCallback, this);
1110         g_settings->deregisterChangedCallback("cinematic",
1111                 &settingChangedCallback, this);
1112         g_settings->deregisterChangedCallback("cinematic_camera_smoothing",
1113                 &settingChangedCallback, this);
1114         g_settings->deregisterChangedCallback("camera_smoothing",
1115                 &settingChangedCallback, this);
1116 }
1117
1118 bool Game::startup(bool *kill,
1119                 InputHandler *input,
1120                 RenderingEngine *rendering_engine,
1121                 const GameStartData &start_data,
1122                 std::string &error_message,
1123                 bool *reconnect,
1124                 ChatBackend *chat_backend)
1125 {
1126
1127         // "cache"
1128         m_rendering_engine        = rendering_engine;
1129         device                    = m_rendering_engine->get_raw_device();
1130         this->kill                = kill;
1131         this->error_message       = &error_message;
1132         reconnect_requested       = reconnect;
1133         this->input               = input;
1134         this->chat_backend        = chat_backend;
1135         simple_singleplayer_mode  = start_data.isSinglePlayer();
1136
1137         input->keycache.populate();
1138
1139         driver = device->getVideoDriver();
1140         smgr = m_rendering_engine->get_scene_manager();
1141
1142         smgr->getParameters()->setAttribute(scene::OBJ_LOADER_IGNORE_MATERIAL_FILES, true);
1143
1144         // Reinit runData
1145         runData = GameRunData();
1146         runData.time_from_last_punch = 10.0;
1147
1148         m_game_ui->initFlags();
1149
1150         m_invert_mouse = g_settings->getBool("invert_mouse");
1151         m_first_loop_after_window_activation = true;
1152
1153 #ifdef HAVE_TOUCHSCREENGUI
1154         m_touch_use_crosshair = g_settings->getBool("touch_use_crosshair");
1155 #endif
1156
1157         g_client_translations->clear();
1158
1159         // address can change if simple_singleplayer_mode
1160         if (!init(start_data.world_spec.path, start_data.address,
1161                         start_data.socket_port, start_data.game_spec))
1162                 return false;
1163
1164         if (!createClient(start_data))
1165                 return false;
1166
1167         m_rendering_engine->initialize(client, hud);
1168
1169         return true;
1170 }
1171
1172
1173 void Game::run()
1174 {
1175         ProfilerGraph graph;
1176         RunStats stats = {};
1177         CameraOrientation cam_view_target = {};
1178         CameraOrientation cam_view = {};
1179         FpsControl draw_times;
1180         f32 dtime; // in seconds
1181
1182         /* Clear the profiler */
1183         Profiler::GraphValues dummyvalues;
1184         g_profiler->graphGet(dummyvalues);
1185
1186         draw_times.reset();
1187
1188         set_light_table(g_settings->getFloat("display_gamma"));
1189
1190 #ifdef HAVE_TOUCHSCREENGUI
1191         m_cache_hold_aux1 = g_settings->getBool("fast_move")
1192                         && client->checkPrivilege("fast");
1193 #endif
1194
1195         v2u32 previous_screen_size(g_settings->getU16("screen_w"),
1196                 g_settings->getU16("screen_h"));
1197
1198         while (m_rendering_engine->run()
1199                         && !(*kill || g_gamecallback->shutdown_requested
1200                         || (server && server->isShutdownRequested()))) {
1201
1202                 // Calculate dtime =
1203                 //    m_rendering_engine->run() from this iteration
1204                 //  + Sleep time until the wanted FPS are reached
1205                 draw_times.limit(device, &dtime);
1206
1207                 const auto current_dynamic_info = getCurrentDynamicInfo();
1208                 if (!current_dynamic_info.equal(client_display_info)) {
1209                         client_display_info = current_dynamic_info;
1210                         dynamic_info_send_timer = 0.2f;
1211                 }
1212
1213                 if (dynamic_info_send_timer > 0) {
1214                         dynamic_info_send_timer -= dtime;
1215                         if (dynamic_info_send_timer <= 0) {
1216                                 client->sendUpdateClientInfo(current_dynamic_info);
1217                         }
1218                 }
1219
1220                 const auto &current_screen_size = current_dynamic_info.render_target_size;
1221
1222                 // Verify if window size has changed and save it if it's the case
1223                 // Ensure evaluating settings->getBool after verifying screensize
1224                 // First condition is cheaper
1225                 if (previous_screen_size != current_screen_size &&
1226                                 current_screen_size != irr::core::dimension2d<u32>(0,0) &&
1227                                 g_settings->getBool("autosave_screensize")) {
1228                         g_settings->setU16("screen_w", current_screen_size.X);
1229                         g_settings->setU16("screen_h", current_screen_size.Y);
1230                         previous_screen_size = current_screen_size;
1231                 }
1232
1233                 // Prepare render data for next iteration
1234
1235                 updateStats(&stats, draw_times, dtime);
1236                 updateInteractTimers(dtime);
1237
1238                 if (!checkConnection())
1239                         break;
1240                 if (!handleCallbacks())
1241                         break;
1242
1243                 processQueues();
1244
1245                 m_game_ui->clearInfoText();
1246
1247                 updateProfilers(stats, draw_times, dtime);
1248                 processUserInput(dtime);
1249                 // Update camera before player movement to avoid camera lag of one frame
1250                 updateCameraDirection(&cam_view_target, dtime);
1251                 cam_view.camera_yaw += (cam_view_target.camera_yaw -
1252                                 cam_view.camera_yaw) * m_cache_cam_smoothing;
1253                 cam_view.camera_pitch += (cam_view_target.camera_pitch -
1254                                 cam_view.camera_pitch) * m_cache_cam_smoothing;
1255                 updatePlayerControl(cam_view);
1256
1257                 {
1258                         bool was_paused = m_is_paused;
1259                         m_is_paused = simple_singleplayer_mode && g_menumgr.pausesGame();
1260                         if (m_is_paused)
1261                                 dtime = 0.0f;
1262
1263                         if (!was_paused && m_is_paused)
1264                                 pauseAnimation();
1265                         else if (was_paused && !m_is_paused)
1266                                 resumeAnimation();
1267                 }
1268
1269                 if (!m_is_paused)
1270                         step(dtime);
1271                 processClientEvents(&cam_view_target);
1272                 updateDebugState();
1273                 updateCamera(dtime);
1274                 updateSound(dtime);
1275                 processPlayerInteraction(dtime, m_game_ui->m_flags.show_hud);
1276                 updateFrame(&graph, &stats, dtime, cam_view);
1277                 updateProfilerGraphs(&graph);
1278
1279                 // Update if minimap has been disabled by the server
1280                 m_game_ui->m_flags.show_minimap &= client->shouldShowMinimap();
1281
1282                 if (m_does_lost_focus_pause_game && !device->isWindowFocused() && !isMenuActive()) {
1283                         showPauseMenu();
1284                 }
1285         }
1286 }
1287
1288
1289 void Game::shutdown()
1290 {
1291         m_rendering_engine->finalize();
1292
1293         auto formspec = m_game_ui->getFormspecGUI();
1294         if (formspec)
1295                 formspec->quitMenu();
1296
1297 #ifdef HAVE_TOUCHSCREENGUI
1298         g_touchscreengui->hide();
1299 #endif
1300
1301         showOverlayMessage(N_("Shutting down..."), 0, 0, false);
1302
1303         if (clouds)
1304                 clouds->drop();
1305
1306         if (gui_chat_console)
1307                 gui_chat_console->drop();
1308
1309         if (sky)
1310                 sky->drop();
1311
1312         /* cleanup menus */
1313         while (g_menumgr.menuCount() > 0) {
1314                 g_menumgr.m_stack.front()->setVisible(false);
1315                 g_menumgr.deletingMenu(g_menumgr.m_stack.front());
1316         }
1317
1318         m_game_ui->deleteFormspec();
1319
1320         chat_backend->addMessage(L"", L"# Disconnected.");
1321         chat_backend->addMessage(L"", L"");
1322         m_chat_log_buf.clear();
1323
1324         if (client) {
1325                 client->Stop();
1326                 while (!client->isShutdown()) {
1327                         assert(texture_src != NULL);
1328                         assert(shader_src != NULL);
1329                         texture_src->processQueue();
1330                         shader_src->processQueue();
1331                         sleep_ms(100);
1332                 }
1333         }
1334 }
1335
1336
1337 /****************************************************************************/
1338 /****************************************************************************
1339  Startup
1340  ****************************************************************************/
1341 /****************************************************************************/
1342
1343 bool Game::init(
1344                 const std::string &map_dir,
1345                 const std::string &address,
1346                 u16 port,
1347                 const SubgameSpec &gamespec)
1348 {
1349         texture_src = createTextureSource();
1350
1351         showOverlayMessage(N_("Loading..."), 0, 0);
1352
1353         shader_src = createShaderSource();
1354
1355         itemdef_manager = createItemDefManager();
1356         nodedef_manager = createNodeDefManager();
1357
1358         eventmgr = new EventManager();
1359         quicktune = new QuicktuneShortcutter();
1360
1361         if (!(texture_src && shader_src && itemdef_manager && nodedef_manager
1362                         && eventmgr && quicktune))
1363                 return false;
1364
1365         if (!initSound())
1366                 return false;
1367
1368         // Create a server if not connecting to an existing one
1369         if (address.empty()) {
1370                 if (!createSingleplayerServer(map_dir, gamespec, port))
1371                         return false;
1372         }
1373
1374         return true;
1375 }
1376
1377 bool Game::initSound()
1378 {
1379 #if USE_SOUND
1380         if (g_settings->getBool("enable_sound") && g_sound_manager_singleton.get()) {
1381                 infostream << "Attempting to use OpenAL audio" << std::endl;
1382                 sound = createOpenALSoundManager(g_sound_manager_singleton.get(), &soundfetcher);
1383                 if (!sound)
1384                         infostream << "Failed to initialize OpenAL audio" << std::endl;
1385         } else
1386                 infostream << "Sound disabled." << std::endl;
1387 #endif
1388
1389         if (!sound) {
1390                 infostream << "Using dummy audio." << std::endl;
1391                 sound = &dummySoundManager;
1392                 sound_is_dummy = true;
1393         }
1394
1395         soundmaker = new SoundMaker(sound, nodedef_manager);
1396         if (!soundmaker)
1397                 return false;
1398
1399         soundmaker->registerReceiver(eventmgr);
1400
1401         return true;
1402 }
1403
1404 bool Game::createSingleplayerServer(const std::string &map_dir,
1405                 const SubgameSpec &gamespec, u16 port)
1406 {
1407         showOverlayMessage(N_("Creating server..."), 0, 5);
1408
1409         std::string bind_str = g_settings->get("bind_address");
1410         Address bind_addr(0, 0, 0, 0, port);
1411
1412         if (g_settings->getBool("ipv6_server")) {
1413                 bind_addr.setAddress((IPv6AddressBytes *) NULL);
1414         }
1415
1416         try {
1417                 bind_addr.Resolve(bind_str.c_str());
1418         } catch (ResolveError &e) {
1419                 infostream << "Resolving bind address \"" << bind_str
1420                            << "\" failed: " << e.what()
1421                            << " -- Listening on all addresses." << std::endl;
1422         }
1423
1424         if (bind_addr.isIPv6() && !g_settings->getBool("enable_ipv6")) {
1425                 *error_message = fmtgettext("Unable to listen on %s because IPv6 is disabled",
1426                         bind_addr.serializeString().c_str());
1427                 errorstream << *error_message << std::endl;
1428                 return false;
1429         }
1430
1431         server = new Server(map_dir, gamespec, simple_singleplayer_mode, bind_addr,
1432                         false, nullptr, error_message);
1433         server->start();
1434
1435         return true;
1436 }
1437
1438 bool Game::createClient(const GameStartData &start_data)
1439 {
1440         showOverlayMessage(N_("Creating client..."), 0, 10);
1441
1442         draw_control = new MapDrawControl();
1443         if (!draw_control)
1444                 return false;
1445
1446         bool could_connect, connect_aborted;
1447 #ifdef HAVE_TOUCHSCREENGUI
1448         if (g_touchscreengui) {
1449                 g_touchscreengui->init(texture_src);
1450                 g_touchscreengui->hide();
1451         }
1452 #endif
1453         if (!connectToServer(start_data, &could_connect, &connect_aborted))
1454                 return false;
1455
1456         if (!could_connect) {
1457                 if (error_message->empty() && !connect_aborted) {
1458                         // Should not happen if error messages are set properly
1459                         *error_message = gettext("Connection failed for unknown reason");
1460                         errorstream << *error_message << std::endl;
1461                 }
1462                 return false;
1463         }
1464
1465         if (!getServerContent(&connect_aborted)) {
1466                 if (error_message->empty() && !connect_aborted) {
1467                         // Should not happen if error messages are set properly
1468                         *error_message = gettext("Connection failed for unknown reason");
1469                         errorstream << *error_message << std::endl;
1470                 }
1471                 return false;
1472         }
1473
1474         auto *scsf = new GameGlobalShaderConstantSetterFactory(
1475                         &m_flags.force_fog_off, &runData.fog_range, client);
1476         shader_src->addShaderConstantSetterFactory(scsf);
1477
1478         // Update cached textures, meshes and materials
1479         client->afterContentReceived();
1480
1481         /* Camera
1482          */
1483         camera = new Camera(*draw_control, client, m_rendering_engine);
1484         if (client->modsLoaded())
1485                 client->getScript()->on_camera_ready(camera);
1486         client->setCamera(camera);
1487 #ifdef HAVE_TOUCHSCREENGUI
1488         if (g_touchscreengui) {
1489                 g_touchscreengui->setUseCrosshair(!isNoCrosshairAllowed());
1490         }
1491 #endif
1492
1493         /* Clouds
1494          */
1495         if (m_cache_enable_clouds)
1496                 clouds = new Clouds(smgr, -1, time(0));
1497
1498         /* Skybox
1499          */
1500         sky = new Sky(-1, m_rendering_engine, texture_src, shader_src);
1501         scsf->setSky(sky);
1502         skybox = NULL;  // This is used/set later on in the main run loop
1503
1504         /* Pre-calculated values
1505          */
1506         video::ITexture *t = texture_src->getTexture("crack_anylength.png");
1507         if (t) {
1508                 v2u32 size = t->getOriginalSize();
1509                 crack_animation_length = size.Y / size.X;
1510         } else {
1511                 crack_animation_length = 5;
1512         }
1513
1514         if (!initGui())
1515                 return false;
1516
1517         /* Set window caption
1518          */
1519         std::wstring str = utf8_to_wide(PROJECT_NAME_C);
1520         str += L" ";
1521         str += utf8_to_wide(g_version_hash);
1522         {
1523                 const wchar_t *text = nullptr;
1524                 if (simple_singleplayer_mode)
1525                         text = wgettext("Singleplayer");
1526                 else
1527                         text = wgettext("Multiplayer");
1528                 str += L" [";
1529                 str += text;
1530                 str += L"]";
1531                 delete[] text;
1532         }
1533         str += L" [";
1534         str += driver->getName();
1535         str += L"]";
1536
1537         device->setWindowCaption(str.c_str());
1538
1539         LocalPlayer *player = client->getEnv().getLocalPlayer();
1540         player->hurt_tilt_timer = 0;
1541         player->hurt_tilt_strength = 0;
1542
1543         hud = new Hud(client, player, &player->inventory);
1544
1545         mapper = client->getMinimap();
1546
1547         if (mapper && client->modsLoaded())
1548                 client->getScript()->on_minimap_ready(mapper);
1549
1550         return true;
1551 }
1552
1553 bool Game::initGui()
1554 {
1555         m_game_ui->init();
1556
1557         // Remove stale "recent" chat messages from previous connections
1558         chat_backend->clearRecentChat();
1559
1560         // Make sure the size of the recent messages buffer is right
1561         chat_backend->applySettings();
1562
1563         // Chat backend and console
1564         gui_chat_console = new GUIChatConsole(guienv, guienv->getRootGUIElement(),
1565                         -1, chat_backend, client, &g_menumgr);
1566
1567 #ifdef HAVE_TOUCHSCREENGUI
1568
1569         if (g_touchscreengui)
1570                 g_touchscreengui->show();
1571
1572 #endif
1573
1574         return true;
1575 }
1576
1577 bool Game::connectToServer(const GameStartData &start_data,
1578                 bool *connect_ok, bool *connection_aborted)
1579 {
1580         *connect_ok = false;    // Let's not be overly optimistic
1581         *connection_aborted = false;
1582         bool local_server_mode = false;
1583
1584         showOverlayMessage(N_("Resolving address..."), 0, 15);
1585
1586         Address connect_address(0, 0, 0, 0, start_data.socket_port);
1587
1588         try {
1589                 connect_address.Resolve(start_data.address.c_str());
1590
1591                 if (connect_address.isZero()) { // i.e. INADDR_ANY, IN6ADDR_ANY
1592                         if (connect_address.isIPv6()) {
1593                                 IPv6AddressBytes addr_bytes;
1594                                 addr_bytes.bytes[15] = 1;
1595                                 connect_address.setAddress(&addr_bytes);
1596                         } else {
1597                                 connect_address.setAddress(127, 0, 0, 1);
1598                         }
1599                         local_server_mode = true;
1600                 }
1601         } catch (ResolveError &e) {
1602                 *error_message = fmtgettext("Couldn't resolve address: %s", e.what());
1603
1604                 errorstream << *error_message << std::endl;
1605                 return false;
1606         }
1607
1608         if (connect_address.isIPv6() && !g_settings->getBool("enable_ipv6")) {
1609                 *error_message = fmtgettext("Unable to connect to %s because IPv6 is disabled", connect_address.serializeString().c_str());
1610                 errorstream << *error_message << std::endl;
1611                 return false;
1612         }
1613
1614         try {
1615                 client = new Client(start_data.name.c_str(),
1616                                 start_data.password, start_data.address,
1617                                 *draw_control, texture_src, shader_src,
1618                                 itemdef_manager, nodedef_manager, sound, eventmgr,
1619                                 m_rendering_engine, connect_address.isIPv6(), m_game_ui.get(),
1620                                 start_data.allow_login_or_register);
1621                 client->migrateModStorage();
1622         } catch (const BaseException &e) {
1623                 *error_message = fmtgettext("Error creating client: %s", e.what());
1624                 errorstream << *error_message << std::endl;
1625                 return false;
1626         }
1627
1628         client->m_simple_singleplayer_mode = simple_singleplayer_mode;
1629
1630         infostream << "Connecting to server at ";
1631         connect_address.print(infostream);
1632         infostream << std::endl;
1633
1634         client->connect(connect_address,
1635                 simple_singleplayer_mode || local_server_mode);
1636
1637         /*
1638                 Wait for server to accept connection
1639         */
1640
1641         try {
1642                 input->clear();
1643
1644                 FpsControl fps_control;
1645                 f32 dtime;
1646                 f32 wait_time = 0; // in seconds
1647
1648                 fps_control.reset();
1649
1650                 while (m_rendering_engine->run()) {
1651
1652                         fps_control.limit(device, &dtime);
1653
1654                         // Update client and server
1655                         client->step(dtime);
1656
1657                         if (server != NULL)
1658                                 server->step(dtime);
1659
1660                         // End condition
1661                         if (client->getState() == LC_Init) {
1662                                 *connect_ok = true;
1663                                 break;
1664                         }
1665
1666                         // Break conditions
1667                         if (*connection_aborted)
1668                                 break;
1669
1670                         if (client->accessDenied()) {
1671                                 *error_message = fmtgettext("Access denied. Reason: %s", client->accessDeniedReason().c_str());
1672                                 *reconnect_requested = client->reconnectRequested();
1673                                 errorstream << *error_message << std::endl;
1674                                 break;
1675                         }
1676
1677                         if (input->cancelPressed()) {
1678                                 *connection_aborted = true;
1679                                 infostream << "Connect aborted [Escape]" << std::endl;
1680                                 break;
1681                         }
1682
1683                         wait_time += dtime;
1684                         // Only time out if we aren't waiting for the server we started
1685                         if (!start_data.address.empty() && wait_time > 10) {
1686                                 *error_message = gettext("Connection timed out.");
1687                                 errorstream << *error_message << std::endl;
1688                                 break;
1689                         }
1690
1691                         // Update status
1692                         showOverlayMessage(N_("Connecting to server..."), dtime, 20);
1693                 }
1694         } catch (con::PeerNotFoundException &e) {
1695                 // TODO: Should something be done here? At least an info/error
1696                 // message?
1697                 return false;
1698         }
1699
1700         return true;
1701 }
1702
1703 bool Game::getServerContent(bool *aborted)
1704 {
1705         input->clear();
1706
1707         FpsControl fps_control;
1708         f32 dtime; // in seconds
1709
1710         fps_control.reset();
1711
1712         while (m_rendering_engine->run()) {
1713
1714                 fps_control.limit(device, &dtime);
1715
1716                 // Update client and server
1717                 client->step(dtime);
1718
1719                 if (server != NULL)
1720                         server->step(dtime);
1721
1722                 // End condition
1723                 if (client->mediaReceived() && client->itemdefReceived() &&
1724                                 client->nodedefReceived()) {
1725                         break;
1726                 }
1727
1728                 // Error conditions
1729                 if (!checkConnection())
1730                         return false;
1731
1732                 if (client->getState() < LC_Init) {
1733                         *error_message = gettext("Client disconnected");
1734                         errorstream << *error_message << std::endl;
1735                         return false;
1736                 }
1737
1738                 if (input->cancelPressed()) {
1739                         *aborted = true;
1740                         infostream << "Connect aborted [Escape]" << std::endl;
1741                         return false;
1742                 }
1743
1744                 // Display status
1745                 int progress = 25;
1746
1747                 if (!client->itemdefReceived()) {
1748                         const wchar_t *text = wgettext("Item definitions...");
1749                         progress = 25;
1750                         m_rendering_engine->draw_load_screen(text, guienv, texture_src,
1751                                 dtime, progress);
1752                         delete[] text;
1753                 } else if (!client->nodedefReceived()) {
1754                         const wchar_t *text = wgettext("Node definitions...");
1755                         progress = 30;
1756                         m_rendering_engine->draw_load_screen(text, guienv, texture_src,
1757                                 dtime, progress);
1758                         delete[] text;
1759                 } else {
1760                         std::ostringstream message;
1761                         std::fixed(message);
1762                         message.precision(0);
1763                         float receive = client->mediaReceiveProgress() * 100;
1764                         message << gettext("Media...");
1765                         if (receive > 0)
1766                                 message << " " << receive << "%";
1767                         message.precision(2);
1768
1769                         if ((USE_CURL == 0) ||
1770                                         (!g_settings->getBool("enable_remote_media_server"))) {
1771                                 float cur = client->getCurRate();
1772                                 std::string cur_unit = gettext("KiB/s");
1773
1774                                 if (cur > 900) {
1775                                         cur /= 1024.0;
1776                                         cur_unit = gettext("MiB/s");
1777                                 }
1778
1779                                 message << " (" << cur << ' ' << cur_unit << ")";
1780                         }
1781
1782                         progress = 30 + client->mediaReceiveProgress() * 35 + 0.5;
1783                         m_rendering_engine->draw_load_screen(utf8_to_wide(message.str()), guienv,
1784                                 texture_src, dtime, progress);
1785                 }
1786         }
1787
1788         return true;
1789 }
1790
1791
1792 /****************************************************************************/
1793 /****************************************************************************
1794  Run
1795  ****************************************************************************/
1796 /****************************************************************************/
1797
1798 inline void Game::updateInteractTimers(f32 dtime)
1799 {
1800         if (runData.nodig_delay_timer >= 0)
1801                 runData.nodig_delay_timer -= dtime;
1802
1803         if (runData.object_hit_delay_timer >= 0)
1804                 runData.object_hit_delay_timer -= dtime;
1805
1806         runData.time_from_last_punch += dtime;
1807 }
1808
1809
1810 /* returns false if game should exit, otherwise true
1811  */
1812 inline bool Game::checkConnection()
1813 {
1814         if (client->accessDenied()) {
1815                 *error_message = fmtgettext("Access denied. Reason: %s", client->accessDeniedReason().c_str());
1816                 *reconnect_requested = client->reconnectRequested();
1817                 errorstream << *error_message << std::endl;
1818                 return false;
1819         }
1820
1821         return true;
1822 }
1823
1824
1825 /* returns false if game should exit, otherwise true
1826  */
1827 inline bool Game::handleCallbacks()
1828 {
1829         if (g_gamecallback->disconnect_requested) {
1830                 g_gamecallback->disconnect_requested = false;
1831                 return false;
1832         }
1833
1834         if (g_gamecallback->changepassword_requested) {
1835                 (new GUIPasswordChange(guienv, guiroot, -1,
1836                                        &g_menumgr, client, texture_src))->drop();
1837                 g_gamecallback->changepassword_requested = false;
1838         }
1839
1840         if (g_gamecallback->changevolume_requested) {
1841                 (new GUIVolumeChange(guienv, guiroot, -1,
1842                                      &g_menumgr, texture_src))->drop();
1843                 g_gamecallback->changevolume_requested = false;
1844         }
1845
1846         if (g_gamecallback->keyconfig_requested) {
1847                 (new GUIKeyChangeMenu(guienv, guiroot, -1,
1848                                       &g_menumgr, texture_src))->drop();
1849                 g_gamecallback->keyconfig_requested = false;
1850         }
1851
1852         if (g_gamecallback->keyconfig_changed) {
1853                 input->keycache.populate(); // update the cache with new settings
1854                 g_gamecallback->keyconfig_changed = false;
1855         }
1856
1857         return true;
1858 }
1859
1860
1861 void Game::processQueues()
1862 {
1863         texture_src->processQueue();
1864         itemdef_manager->processQueue(client);
1865         shader_src->processQueue();
1866 }
1867
1868 void Game::updateDebugState()
1869 {
1870         LocalPlayer *player = client->getEnv().getLocalPlayer();
1871
1872         // debug UI and wireframe
1873         bool has_debug = client->checkPrivilege("debug");
1874         bool has_basic_debug = has_debug || (player->hud_flags & HUD_FLAG_BASIC_DEBUG);
1875
1876         if (m_game_ui->m_flags.show_basic_debug) {
1877                 if (!has_basic_debug)
1878                         m_game_ui->m_flags.show_basic_debug = false;
1879         } else if (m_game_ui->m_flags.show_minimal_debug) {
1880                 if (has_basic_debug)
1881                         m_game_ui->m_flags.show_basic_debug = true;
1882         }
1883         if (!has_basic_debug)
1884                 hud->disableBlockBounds();
1885         if (!has_debug)
1886                 draw_control->show_wireframe = false;
1887
1888         // noclip
1889         draw_control->allow_noclip = m_cache_enable_noclip && client->checkPrivilege("noclip");
1890 }
1891
1892 void Game::updateProfilers(const RunStats &stats, const FpsControl &draw_times,
1893                 f32 dtime)
1894 {
1895         float profiler_print_interval =
1896                         g_settings->getFloat("profiler_print_interval");
1897         bool print_to_log = true;
1898
1899         if (profiler_print_interval == 0) {
1900                 print_to_log = false;
1901                 profiler_print_interval = 3;
1902         }
1903
1904         if (profiler_interval.step(dtime, profiler_print_interval)) {
1905                 if (print_to_log) {
1906                         infostream << "Profiler:" << std::endl;
1907                         g_profiler->print(infostream);
1908                 }
1909
1910                 m_game_ui->updateProfiler();
1911                 g_profiler->clear();
1912         }
1913
1914         // Update update graphs
1915         g_profiler->graphAdd("Time non-rendering [us]",
1916                 draw_times.busy_time - stats.drawtime);
1917
1918         g_profiler->graphAdd("Sleep [us]", draw_times.sleep_time);
1919         g_profiler->graphAdd("FPS", 1.0f / dtime);
1920 }
1921
1922 void Game::updateStats(RunStats *stats, const FpsControl &draw_times,
1923                 f32 dtime)
1924 {
1925
1926         f32 jitter;
1927         Jitter *jp;
1928
1929         /* Time average and jitter calculation
1930          */
1931         jp = &stats->dtime_jitter;
1932         jp->avg = jp->avg * 0.96 + dtime * 0.04;
1933
1934         jitter = dtime - jp->avg;
1935
1936         if (jitter > jp->max)
1937                 jp->max = jitter;
1938
1939         jp->counter += dtime;
1940
1941         if (jp->counter > 0.0) {
1942                 jp->counter -= 3.0;
1943                 jp->max_sample = jp->max;
1944                 jp->max_fraction = jp->max_sample / (jp->avg + 0.001);
1945                 jp->max = 0.0;
1946         }
1947
1948         /* Busytime average and jitter calculation
1949          */
1950         jp = &stats->busy_time_jitter;
1951         jp->avg = jp->avg + draw_times.getBusyMs() * 0.02;
1952
1953         jitter = draw_times.getBusyMs() - jp->avg;
1954
1955         if (jitter > jp->max)
1956                 jp->max = jitter;
1957         if (jitter < jp->min)
1958                 jp->min = jitter;
1959
1960         jp->counter += dtime;
1961
1962         if (jp->counter > 0.0) {
1963                 jp->counter -= 3.0;
1964                 jp->max_sample = jp->max;
1965                 jp->min_sample = jp->min;
1966                 jp->max = 0.0;
1967                 jp->min = 0.0;
1968         }
1969 }
1970
1971
1972
1973 /****************************************************************************
1974  Input handling
1975  ****************************************************************************/
1976
1977 void Game::processUserInput(f32 dtime)
1978 {
1979         // Reset input if window not active or some menu is active
1980         if (!device->isWindowActive() || isMenuActive() || guienv->hasFocus(gui_chat_console)) {
1981                 input->clear();
1982 #ifdef HAVE_TOUCHSCREENGUI
1983                 g_touchscreengui->hide();
1984 #endif
1985         }
1986 #ifdef HAVE_TOUCHSCREENGUI
1987         else if (g_touchscreengui) {
1988                 /* on touchscreengui step may generate own input events which ain't
1989                  * what we want in case we just did clear them */
1990                 g_touchscreengui->show();
1991                 g_touchscreengui->step(dtime);
1992         }
1993 #endif
1994
1995         if (!guienv->hasFocus(gui_chat_console) && gui_chat_console->isOpen()) {
1996                 gui_chat_console->closeConsoleAtOnce();
1997         }
1998
1999         // Input handler step() (used by the random input generator)
2000         input->step(dtime);
2001
2002 #ifdef __ANDROID__
2003         auto formspec = m_game_ui->getFormspecGUI();
2004         if (formspec)
2005                 formspec->getAndroidUIInput();
2006         else
2007                 handleAndroidChatInput();
2008 #endif
2009
2010         // Increase timer for double tap of "keymap_jump"
2011         if (m_cache_doubletap_jump && runData.jump_timer_up <= 0.2f)
2012                 runData.jump_timer_up += dtime;
2013         if (m_cache_doubletap_jump && runData.jump_timer_down <= 0.4f)
2014                 runData.jump_timer_down += dtime;
2015
2016         processKeyInput();
2017         processItemSelection(&runData.new_playeritem);
2018 }
2019
2020
2021 void Game::processKeyInput()
2022 {
2023         if (wasKeyDown(KeyType::DROP)) {
2024                 dropSelectedItem(isKeyDown(KeyType::SNEAK));
2025         } else if (wasKeyDown(KeyType::AUTOFORWARD)) {
2026                 toggleAutoforward();
2027         } else if (wasKeyDown(KeyType::BACKWARD)) {
2028                 if (g_settings->getBool("continuous_forward"))
2029                         toggleAutoforward();
2030         } else if (wasKeyDown(KeyType::INVENTORY)) {
2031                 openInventory();
2032         } else if (input->cancelPressed()) {
2033 #ifdef __ANDROID__
2034                 m_android_chat_open = false;
2035 #endif
2036                 if (!gui_chat_console->isOpenInhibited()) {
2037                         showPauseMenu();
2038                 }
2039         } else if (wasKeyDown(KeyType::CHAT)) {
2040                 openConsole(0.2, L"");
2041         } else if (wasKeyDown(KeyType::CMD)) {
2042                 openConsole(0.2, L"/");
2043         } else if (wasKeyDown(KeyType::CMD_LOCAL)) {
2044                 if (client->modsLoaded())
2045                         openConsole(0.2, L".");
2046                 else
2047                         m_game_ui->showTranslatedStatusText("Client side scripting is disabled");
2048         } else if (wasKeyDown(KeyType::CONSOLE)) {
2049                 openConsole(core::clamp(g_settings->getFloat("console_height"), 0.1f, 1.0f));
2050         } else if (wasKeyDown(KeyType::FREEMOVE)) {
2051                 toggleFreeMove();
2052         } else if (wasKeyDown(KeyType::JUMP)) {
2053                 toggleFreeMoveAlt();
2054         } else if (wasKeyDown(KeyType::PITCHMOVE)) {
2055                 togglePitchMove();
2056         } else if (wasKeyDown(KeyType::FASTMOVE)) {
2057                 toggleFast();
2058         } else if (wasKeyDown(KeyType::NOCLIP)) {
2059                 toggleNoClip();
2060 #if USE_SOUND
2061         } else if (wasKeyDown(KeyType::MUTE)) {
2062                 if (g_settings->getBool("enable_sound")) {
2063                         bool new_mute_sound = !g_settings->getBool("mute_sound");
2064                         g_settings->setBool("mute_sound", new_mute_sound);
2065                         if (new_mute_sound)
2066                                 m_game_ui->showTranslatedStatusText("Sound muted");
2067                         else
2068                                 m_game_ui->showTranslatedStatusText("Sound unmuted");
2069                 } else {
2070                         m_game_ui->showTranslatedStatusText("Sound system is disabled");
2071                 }
2072         } else if (wasKeyDown(KeyType::INC_VOLUME)) {
2073                 if (g_settings->getBool("enable_sound")) {
2074                         float new_volume = g_settings->getFloat("sound_volume", 0.0f, 0.9f) + 0.1f;
2075                         g_settings->setFloat("sound_volume", new_volume);
2076                         std::wstring msg = fwgettext("Volume changed to %d%%", myround(new_volume * 100));
2077                         m_game_ui->showStatusText(msg);
2078                 } else {
2079                         m_game_ui->showTranslatedStatusText("Sound system is disabled");
2080                 }
2081         } else if (wasKeyDown(KeyType::DEC_VOLUME)) {
2082                 if (g_settings->getBool("enable_sound")) {
2083                         float new_volume = g_settings->getFloat("sound_volume", 0.1f, 1.0f) - 0.1f;
2084                         g_settings->setFloat("sound_volume", new_volume);
2085                         std::wstring msg = fwgettext("Volume changed to %d%%", myround(new_volume * 100));
2086                         m_game_ui->showStatusText(msg);
2087                 } else {
2088                         m_game_ui->showTranslatedStatusText("Sound system is disabled");
2089                 }
2090 #else
2091         } else if (wasKeyDown(KeyType::MUTE) || wasKeyDown(KeyType::INC_VOLUME)
2092                         || wasKeyDown(KeyType::DEC_VOLUME)) {
2093                 m_game_ui->showTranslatedStatusText("Sound system is not supported on this build");
2094 #endif
2095         } else if (wasKeyDown(KeyType::CINEMATIC)) {
2096                 toggleCinematic();
2097         } else if (wasKeyDown(KeyType::SCREENSHOT)) {
2098                 client->makeScreenshot();
2099         } else if (wasKeyDown(KeyType::TOGGLE_BLOCK_BOUNDS)) {
2100                 toggleBlockBounds();
2101         } else if (wasKeyDown(KeyType::TOGGLE_HUD)) {
2102                 m_game_ui->toggleHud();
2103         } else if (wasKeyDown(KeyType::MINIMAP)) {
2104                 toggleMinimap(isKeyDown(KeyType::SNEAK));
2105         } else if (wasKeyDown(KeyType::TOGGLE_CHAT)) {
2106                 m_game_ui->toggleChat(client);
2107         } else if (wasKeyDown(KeyType::TOGGLE_FOG)) {
2108                 toggleFog();
2109         } else if (wasKeyDown(KeyType::TOGGLE_UPDATE_CAMERA)) {
2110                 toggleUpdateCamera();
2111         } else if (wasKeyDown(KeyType::TOGGLE_DEBUG)) {
2112                 toggleDebug();
2113         } else if (wasKeyDown(KeyType::TOGGLE_PROFILER)) {
2114                 m_game_ui->toggleProfiler();
2115         } else if (wasKeyDown(KeyType::INCREASE_VIEWING_RANGE)) {
2116                 increaseViewRange();
2117         } else if (wasKeyDown(KeyType::DECREASE_VIEWING_RANGE)) {
2118                 decreaseViewRange();
2119         } else if (wasKeyDown(KeyType::RANGESELECT)) {
2120                 toggleFullViewRange();
2121         } else if (wasKeyDown(KeyType::ZOOM)) {
2122                 checkZoomEnabled();
2123         } else if (wasKeyDown(KeyType::QUICKTUNE_NEXT)) {
2124                 quicktune->next();
2125         } else if (wasKeyDown(KeyType::QUICKTUNE_PREV)) {
2126                 quicktune->prev();
2127         } else if (wasKeyDown(KeyType::QUICKTUNE_INC)) {
2128                 quicktune->inc();
2129         } else if (wasKeyDown(KeyType::QUICKTUNE_DEC)) {
2130                 quicktune->dec();
2131         }
2132
2133         if (!isKeyDown(KeyType::JUMP) && runData.reset_jump_timer) {
2134                 runData.reset_jump_timer = false;
2135                 runData.jump_timer_up = 0.0f;
2136         }
2137
2138         if (quicktune->hasMessage()) {
2139                 m_game_ui->showStatusText(utf8_to_wide(quicktune->getMessage()));
2140         }
2141 }
2142
2143 void Game::processItemSelection(u16 *new_playeritem)
2144 {
2145         LocalPlayer *player = client->getEnv().getLocalPlayer();
2146
2147         /* Item selection using mouse wheel
2148          */
2149         *new_playeritem = player->getWieldIndex();
2150         s32 wheel = input->getMouseWheel();
2151         u16 max_item = MYMIN(PLAYER_INVENTORY_SIZE - 1,
2152                     player->hud_hotbar_itemcount - 1);
2153
2154         s32 dir = wheel;
2155
2156         if (wasKeyDown(KeyType::HOTBAR_NEXT))
2157                 dir = -1;
2158
2159         if (wasKeyDown(KeyType::HOTBAR_PREV))
2160                 dir = 1;
2161
2162         if (dir < 0)
2163                 *new_playeritem = *new_playeritem < max_item ? *new_playeritem + 1 : 0;
2164         else if (dir > 0)
2165                 *new_playeritem = *new_playeritem > 0 ? *new_playeritem - 1 : max_item;
2166         // else dir == 0
2167
2168         /* Item selection using hotbar slot keys
2169          */
2170         for (u16 i = 0; i <= max_item; i++) {
2171                 if (wasKeyDown((GameKeyType) (KeyType::SLOT_1 + i))) {
2172                         *new_playeritem = i;
2173                         break;
2174                 }
2175         }
2176
2177         // Clamp selection again in case it wasn't changed but max_item was
2178         *new_playeritem = MYMIN(*new_playeritem, max_item);
2179 }
2180
2181
2182 void Game::dropSelectedItem(bool single_item)
2183 {
2184         IDropAction *a = new IDropAction();
2185         a->count = single_item ? 1 : 0;
2186         a->from_inv.setCurrentPlayer();
2187         a->from_list = "main";
2188         a->from_i = client->getEnv().getLocalPlayer()->getWieldIndex();
2189         client->inventoryAction(a);
2190 }
2191
2192
2193 void Game::openInventory()
2194 {
2195         /*
2196          * Don't permit to open inventory is CAO or player doesn't exists.
2197          * This prevent showing an empty inventory at player load
2198          */
2199
2200         LocalPlayer *player = client->getEnv().getLocalPlayer();
2201         if (!player || !player->getCAO())
2202                 return;
2203
2204         infostream << "Game: Launching inventory" << std::endl;
2205
2206         PlayerInventoryFormSource *fs_src = new PlayerInventoryFormSource(client);
2207
2208         InventoryLocation inventoryloc;
2209         inventoryloc.setCurrentPlayer();
2210
2211         if (client->modsLoaded() && client->getScript()->on_inventory_open(fs_src->m_client->getInventory(inventoryloc))) {
2212                 delete fs_src;
2213                 return;
2214         }
2215
2216         if (fs_src->getForm().empty()) {
2217                 delete fs_src;
2218                 return;
2219         }
2220
2221         TextDest *txt_dst = new TextDestPlayerInventory(client);
2222         auto *&formspec = m_game_ui->updateFormspec("");
2223         GUIFormSpecMenu::create(formspec, client, m_rendering_engine->get_gui_env(),
2224                 &input->joystick, fs_src, txt_dst, client->getFormspecPrepend(), sound);
2225
2226         formspec->setFormSpec(fs_src->getForm(), inventoryloc);
2227 }
2228
2229
2230 void Game::openConsole(float scale, const wchar_t *line)
2231 {
2232         assert(scale > 0.0f && scale <= 1.0f);
2233
2234 #ifdef __ANDROID__
2235         porting::showInputDialog(gettext("ok"), "", "", 2);
2236         m_android_chat_open = true;
2237 #else
2238         if (gui_chat_console->isOpenInhibited())
2239                 return;
2240         gui_chat_console->openConsole(scale);
2241         if (line) {
2242                 gui_chat_console->setCloseOnEnter(true);
2243                 gui_chat_console->replaceAndAddToHistory(line);
2244         }
2245 #endif
2246 }
2247
2248 #ifdef __ANDROID__
2249 void Game::handleAndroidChatInput()
2250 {
2251         if (m_android_chat_open && porting::getInputDialogState() == 0) {
2252                 std::string text = porting::getInputDialogValue();
2253                 client->typeChatMessage(utf8_to_wide(text));
2254                 m_android_chat_open = false;
2255         }
2256 }
2257 #endif
2258
2259
2260 void Game::toggleFreeMove()
2261 {
2262         bool free_move = !g_settings->getBool("free_move");
2263         g_settings->set("free_move", bool_to_cstr(free_move));
2264
2265         if (free_move) {
2266                 if (client->checkPrivilege("fly")) {
2267                         m_game_ui->showTranslatedStatusText("Fly mode enabled");
2268                 } else {
2269                         m_game_ui->showTranslatedStatusText("Fly mode enabled (note: no 'fly' privilege)");
2270                 }
2271         } else {
2272                 m_game_ui->showTranslatedStatusText("Fly mode disabled");
2273         }
2274 }
2275
2276 void Game::toggleFreeMoveAlt()
2277 {
2278         if (!runData.reset_jump_timer) {
2279                 runData.jump_timer_down_before = runData.jump_timer_down;
2280                 runData.jump_timer_down = 0.0f;
2281         }
2282
2283         // key down (0.2 s max.), then key up (0.2 s max.), then key down
2284         if (m_cache_doubletap_jump && runData.jump_timer_up < 0.2f &&
2285                         runData.jump_timer_down_before < 0.4f) // 0.2 + 0.2
2286                 toggleFreeMove();
2287
2288         runData.reset_jump_timer = true;
2289 }
2290
2291
2292 void Game::togglePitchMove()
2293 {
2294         bool pitch_move = !g_settings->getBool("pitch_move");
2295         g_settings->set("pitch_move", bool_to_cstr(pitch_move));
2296
2297         if (pitch_move) {
2298                 m_game_ui->showTranslatedStatusText("Pitch move mode enabled");
2299         } else {
2300                 m_game_ui->showTranslatedStatusText("Pitch move mode disabled");
2301         }
2302 }
2303
2304
2305 void Game::toggleFast()
2306 {
2307         bool fast_move = !g_settings->getBool("fast_move");
2308         bool has_fast_privs = client->checkPrivilege("fast");
2309         g_settings->set("fast_move", bool_to_cstr(fast_move));
2310
2311         if (fast_move) {
2312                 if (has_fast_privs) {
2313                         m_game_ui->showTranslatedStatusText("Fast mode enabled");
2314                 } else {
2315                         m_game_ui->showTranslatedStatusText("Fast mode enabled (note: no 'fast' privilege)");
2316                 }
2317         } else {
2318                 m_game_ui->showTranslatedStatusText("Fast mode disabled");
2319         }
2320
2321 #ifdef HAVE_TOUCHSCREENGUI
2322         m_cache_hold_aux1 = fast_move && has_fast_privs;
2323 #endif
2324 }
2325
2326
2327 void Game::toggleNoClip()
2328 {
2329         bool noclip = !g_settings->getBool("noclip");
2330         g_settings->set("noclip", bool_to_cstr(noclip));
2331
2332         if (noclip) {
2333                 if (client->checkPrivilege("noclip")) {
2334                         m_game_ui->showTranslatedStatusText("Noclip mode enabled");
2335                 } else {
2336                         m_game_ui->showTranslatedStatusText("Noclip mode enabled (note: no 'noclip' privilege)");
2337                 }
2338         } else {
2339                 m_game_ui->showTranslatedStatusText("Noclip mode disabled");
2340         }
2341 }
2342
2343 void Game::toggleCinematic()
2344 {
2345         bool cinematic = !g_settings->getBool("cinematic");
2346         g_settings->set("cinematic", bool_to_cstr(cinematic));
2347
2348         if (cinematic)
2349                 m_game_ui->showTranslatedStatusText("Cinematic mode enabled");
2350         else
2351                 m_game_ui->showTranslatedStatusText("Cinematic mode disabled");
2352 }
2353
2354 void Game::toggleBlockBounds()
2355 {
2356         LocalPlayer *player = client->getEnv().getLocalPlayer();
2357         if (!(client->checkPrivilege("debug") || (player->hud_flags & HUD_FLAG_BASIC_DEBUG))) {
2358                 m_game_ui->showTranslatedStatusText("Can't show block bounds (disabled by mod or game)");
2359                 return;
2360         }
2361         enum Hud::BlockBoundsMode newmode = hud->toggleBlockBounds();
2362         switch (newmode) {
2363                 case Hud::BLOCK_BOUNDS_OFF:
2364                         m_game_ui->showTranslatedStatusText("Block bounds hidden");
2365                         break;
2366                 case Hud::BLOCK_BOUNDS_CURRENT:
2367                         m_game_ui->showTranslatedStatusText("Block bounds shown for current block");
2368                         break;
2369                 case Hud::BLOCK_BOUNDS_NEAR:
2370                         m_game_ui->showTranslatedStatusText("Block bounds shown for nearby blocks");
2371                         break;
2372                 case Hud::BLOCK_BOUNDS_MAX:
2373                         m_game_ui->showTranslatedStatusText("Block bounds shown for all blocks");
2374                         break;
2375                 default:
2376                         break;
2377         }
2378 }
2379
2380 // Autoforward by toggling continuous forward.
2381 void Game::toggleAutoforward()
2382 {
2383         bool autorun_enabled = !g_settings->getBool("continuous_forward");
2384         g_settings->set("continuous_forward", bool_to_cstr(autorun_enabled));
2385
2386         if (autorun_enabled)
2387                 m_game_ui->showTranslatedStatusText("Automatic forward enabled");
2388         else
2389                 m_game_ui->showTranslatedStatusText("Automatic forward disabled");
2390 }
2391
2392 void Game::toggleMinimap(bool shift_pressed)
2393 {
2394         if (!mapper || !m_game_ui->m_flags.show_hud || !g_settings->getBool("enable_minimap"))
2395                 return;
2396
2397         if (shift_pressed)
2398                 mapper->toggleMinimapShape();
2399         else
2400                 mapper->nextMode();
2401
2402         // TODO: When legacy minimap is deprecated, keep only HUD minimap stuff here
2403
2404         // Not so satisying code to keep compatibility with old fixed mode system
2405         // -->
2406         u32 hud_flags = client->getEnv().getLocalPlayer()->hud_flags;
2407
2408         if (!(hud_flags & HUD_FLAG_MINIMAP_VISIBLE)) {
2409                 m_game_ui->m_flags.show_minimap = false;
2410         } else {
2411
2412         // If radar is disabled, try to find a non radar mode or fall back to 0
2413                 if (!(hud_flags & HUD_FLAG_MINIMAP_RADAR_VISIBLE))
2414                         while (mapper->getModeIndex() &&
2415                                         mapper->getModeDef().type == MINIMAP_TYPE_RADAR)
2416                                 mapper->nextMode();
2417
2418                 m_game_ui->m_flags.show_minimap = mapper->getModeDef().type !=
2419                                 MINIMAP_TYPE_OFF;
2420         }
2421         // <--
2422         // End of 'not so satifying code'
2423         if ((hud_flags & HUD_FLAG_MINIMAP_VISIBLE) ||
2424                         (hud && hud->hasElementOfType(HUD_ELEM_MINIMAP)))
2425                 m_game_ui->showStatusText(utf8_to_wide(mapper->getModeDef().label));
2426         else
2427                 m_game_ui->showTranslatedStatusText("Minimap currently disabled by game or mod");
2428 }
2429
2430 void Game::toggleFog()
2431 {
2432         bool fog_enabled = g_settings->getBool("enable_fog");
2433         g_settings->setBool("enable_fog", !fog_enabled);
2434         if (fog_enabled)
2435                 m_game_ui->showTranslatedStatusText("Fog disabled");
2436         else
2437                 m_game_ui->showTranslatedStatusText("Fog enabled");
2438 }
2439
2440
2441 void Game::toggleDebug()
2442 {
2443         LocalPlayer *player = client->getEnv().getLocalPlayer();
2444         bool has_debug = client->checkPrivilege("debug");
2445         bool has_basic_debug = has_debug || (player->hud_flags & HUD_FLAG_BASIC_DEBUG);
2446         // Initial: No debug info
2447         // 1x toggle: Debug text
2448         // 2x toggle: Debug text with profiler graph
2449         // 3x toggle: Debug text and wireframe (needs "debug" priv)
2450         // Next toggle: Back to initial
2451         //
2452         // The debug text can be in 2 modes: minimal and basic.
2453         // * Minimal: Only technical client info that not gameplay-relevant
2454         // * Basic: Info that might give gameplay advantage, e.g. pos, angle
2455         // Basic mode is used when player has the debug HUD flag set,
2456         // otherwise the Minimal mode is used.
2457         if (!m_game_ui->m_flags.show_minimal_debug) {
2458                 m_game_ui->m_flags.show_minimal_debug = true;
2459                 if (has_basic_debug)
2460                         m_game_ui->m_flags.show_basic_debug = true;
2461                 m_game_ui->m_flags.show_profiler_graph = false;
2462                 draw_control->show_wireframe = false;
2463                 m_game_ui->showTranslatedStatusText("Debug info shown");
2464         } else if (!m_game_ui->m_flags.show_profiler_graph && !draw_control->show_wireframe) {
2465                 if (has_basic_debug)
2466                         m_game_ui->m_flags.show_basic_debug = true;
2467                 m_game_ui->m_flags.show_profiler_graph = true;
2468                 m_game_ui->showTranslatedStatusText("Profiler graph shown");
2469         } else if (!draw_control->show_wireframe && client->checkPrivilege("debug")) {
2470                 if (has_basic_debug)
2471                         m_game_ui->m_flags.show_basic_debug = true;
2472                 m_game_ui->m_flags.show_profiler_graph = false;
2473                 draw_control->show_wireframe = true;
2474                 m_game_ui->showTranslatedStatusText("Wireframe shown");
2475         } else {
2476                 m_game_ui->m_flags.show_minimal_debug = false;
2477                 m_game_ui->m_flags.show_basic_debug = false;
2478                 m_game_ui->m_flags.show_profiler_graph = false;
2479                 draw_control->show_wireframe = false;
2480                 if (has_debug) {
2481                         m_game_ui->showTranslatedStatusText("Debug info, profiler graph, and wireframe hidden");
2482                 } else {
2483                         m_game_ui->showTranslatedStatusText("Debug info and profiler graph hidden");
2484                 }
2485         }
2486 }
2487
2488
2489 void Game::toggleUpdateCamera()
2490 {
2491         m_flags.disable_camera_update = !m_flags.disable_camera_update;
2492         if (m_flags.disable_camera_update)
2493                 m_game_ui->showTranslatedStatusText("Camera update disabled");
2494         else
2495                 m_game_ui->showTranslatedStatusText("Camera update enabled");
2496 }
2497
2498
2499 void Game::increaseViewRange()
2500 {
2501         s16 range = g_settings->getS16("viewing_range");
2502         s16 range_new = range + 10;
2503
2504         if (range_new > 4000) {
2505                 range_new = 4000;
2506                 std::wstring msg = fwgettext("Viewing range is at maximum: %d", range_new);
2507                 m_game_ui->showStatusText(msg);
2508         } else {
2509                 std::wstring msg = fwgettext("Viewing range changed to %d", range_new);
2510                 m_game_ui->showStatusText(msg);
2511         }
2512         g_settings->set("viewing_range", itos(range_new));
2513 }
2514
2515
2516 void Game::decreaseViewRange()
2517 {
2518         s16 range = g_settings->getS16("viewing_range");
2519         s16 range_new = range - 10;
2520
2521         if (range_new < 20) {
2522                 range_new = 20;
2523                 std::wstring msg = fwgettext("Viewing range is at minimum: %d", range_new);
2524                 m_game_ui->showStatusText(msg);
2525         } else {
2526                 std::wstring msg = fwgettext("Viewing range changed to %d", range_new);
2527                 m_game_ui->showStatusText(msg);
2528         }
2529         g_settings->set("viewing_range", itos(range_new));
2530 }
2531
2532
2533 void Game::toggleFullViewRange()
2534 {
2535         draw_control->range_all = !draw_control->range_all;
2536         if (draw_control->range_all)
2537                 m_game_ui->showTranslatedStatusText("Enabled unlimited viewing range");
2538         else
2539                 m_game_ui->showTranslatedStatusText("Disabled unlimited viewing range");
2540 }
2541
2542
2543 void Game::checkZoomEnabled()
2544 {
2545         LocalPlayer *player = client->getEnv().getLocalPlayer();
2546         if (player->getZoomFOV() < 0.001f || player->getFov().fov > 0.0f)
2547                 m_game_ui->showTranslatedStatusText("Zoom currently disabled by game or mod");
2548 }
2549
2550 void Game::updateCameraDirection(CameraOrientation *cam, float dtime)
2551 {
2552 #ifndef __ANDROID__
2553         if (isMenuActive())
2554                 device->getCursorControl()->setRelativeMode(false);
2555         else
2556                 device->getCursorControl()->setRelativeMode(true);
2557 #endif
2558
2559         if ((device->isWindowActive() && device->isWindowFocused()
2560                         && !isMenuActive()) || input->isRandom()) {
2561
2562 #ifndef __ANDROID__
2563                 if (!input->isRandom()) {
2564                         // Mac OSX gets upset if this is set every frame
2565                         if (device->getCursorControl()->isVisible())
2566                                 device->getCursorControl()->setVisible(false);
2567                 }
2568 #endif
2569
2570                 if (m_first_loop_after_window_activation) {
2571                         m_first_loop_after_window_activation = false;
2572
2573                         input->setMousePos(driver->getScreenSize().Width / 2,
2574                                 driver->getScreenSize().Height / 2);
2575                 } else {
2576                         updateCameraOrientation(cam, dtime);
2577                 }
2578
2579         } else {
2580
2581 #ifndef ANDROID
2582                 // Mac OSX gets upset if this is set every frame
2583                 if (!device->getCursorControl()->isVisible())
2584                         device->getCursorControl()->setVisible(true);
2585 #endif
2586
2587                 m_first_loop_after_window_activation = true;
2588
2589         }
2590 }
2591
2592 // Get the factor to multiply with sensitivity to get the same mouse/joystick
2593 // responsiveness independently of FOV.
2594 f32 Game::getSensitivityScaleFactor() const
2595 {
2596         f32 fov_y = client->getCamera()->getFovY();
2597
2598         // Multiply by a constant such that it becomes 1.0 at 72 degree FOV and
2599         // 16:9 aspect ratio to minimize disruption of existing sensitivity
2600         // settings.
2601         return tan(fov_y / 2.0f) * 1.3763818698f;
2602 }
2603
2604 ClientDynamicInfo Game::getCurrentDynamicInfo() const
2605 {
2606         v2u32 screen_size = RenderingEngine::getWindowSize();
2607         f32 density = RenderingEngine::getDisplayDensity();
2608         f32 gui_scaling = g_settings->getFloat("gui_scaling") * density;
2609         f32 hud_scaling = g_settings->getFloat("hud_scaling") * density;
2610
2611         return {
2612                 screen_size, gui_scaling, hud_scaling,
2613                 ClientDynamicInfo::calculateMaxFSSize(screen_size)
2614         };
2615 }
2616
2617 void Game::updateCameraOrientation(CameraOrientation *cam, float dtime)
2618 {
2619 #ifdef HAVE_TOUCHSCREENGUI
2620         if (g_touchscreengui) {
2621                 cam->camera_yaw   += g_touchscreengui->getYawChange();
2622                 cam->camera_pitch  = g_touchscreengui->getPitch();
2623         } else {
2624 #endif
2625                 v2s32 center(driver->getScreenSize().Width / 2, driver->getScreenSize().Height / 2);
2626                 v2s32 dist = input->getMousePos() - center;
2627
2628                 if (m_invert_mouse || camera->getCameraMode() == CAMERA_MODE_THIRD_FRONT) {
2629                         dist.Y = -dist.Y;
2630                 }
2631
2632                 f32 sens_scale = getSensitivityScaleFactor();
2633                 cam->camera_yaw   -= dist.X * m_cache_mouse_sensitivity * sens_scale;
2634                 cam->camera_pitch += dist.Y * m_cache_mouse_sensitivity * sens_scale;
2635
2636                 if (dist.X != 0 || dist.Y != 0)
2637                         input->setMousePos(center.X, center.Y);
2638 #ifdef HAVE_TOUCHSCREENGUI
2639         }
2640 #endif
2641
2642         if (m_cache_enable_joysticks) {
2643                 f32 sens_scale = getSensitivityScaleFactor();
2644                 f32 c = m_cache_joystick_frustum_sensitivity * dtime * sens_scale;
2645                 cam->camera_yaw -= input->joystick.getAxisWithoutDead(JA_FRUSTUM_HORIZONTAL) * c;
2646                 cam->camera_pitch += input->joystick.getAxisWithoutDead(JA_FRUSTUM_VERTICAL) * c;
2647         }
2648
2649         cam->camera_pitch = rangelim(cam->camera_pitch, -89.5, 89.5);
2650 }
2651
2652
2653 void Game::updatePlayerControl(const CameraOrientation &cam)
2654 {
2655         LocalPlayer *player = client->getEnv().getLocalPlayer();
2656
2657         //TimeTaker tt("update player control", NULL, PRECISION_NANO);
2658
2659         PlayerControl control(
2660                 isKeyDown(KeyType::FORWARD),
2661                 isKeyDown(KeyType::BACKWARD),
2662                 isKeyDown(KeyType::LEFT),
2663                 isKeyDown(KeyType::RIGHT),
2664                 isKeyDown(KeyType::JUMP) || player->getAutojump(),
2665                 isKeyDown(KeyType::AUX1),
2666                 isKeyDown(KeyType::SNEAK),
2667                 isKeyDown(KeyType::ZOOM),
2668                 isKeyDown(KeyType::DIG),
2669                 isKeyDown(KeyType::PLACE),
2670                 cam.camera_pitch,
2671                 cam.camera_yaw,
2672                 input->getMovementSpeed(),
2673                 input->getMovementDirection()
2674         );
2675
2676         // autoforward if set: move at maximum speed
2677         if (player->getPlayerSettings().continuous_forward &&
2678                         client->activeObjectsReceived() && !player->isDead()) {
2679                 control.movement_speed = 1.0f;
2680                 // sideways movement only
2681                 float dx = sin(control.movement_direction);
2682                 control.movement_direction = atan2(dx, 1.0f);
2683         }
2684
2685 #ifdef HAVE_TOUCHSCREENGUI
2686         /* For touch, simulate holding down AUX1 (fast move) if the user has
2687          * the fast_move setting toggled on. If there is an aux1 key defined for
2688          * touch then its meaning is inverted (i.e. holding aux1 means walk and
2689          * not fast)
2690          */
2691         if (m_cache_hold_aux1) {
2692                 control.aux1 = control.aux1 ^ true;
2693         }
2694 #endif
2695
2696         client->setPlayerControl(control);
2697
2698         //tt.stop();
2699 }
2700
2701
2702 inline void Game::step(f32 dtime)
2703 {
2704         if (server)
2705                 server->step(dtime);
2706
2707         client->step(dtime);
2708 }
2709
2710 static void pauseNodeAnimation(PausedNodesList &paused, scene::ISceneNode *node) {
2711         if (!node)
2712                 return;
2713         for (auto &&child: node->getChildren())
2714                 pauseNodeAnimation(paused, child);
2715         if (node->getType() != scene::ESNT_ANIMATED_MESH)
2716                 return;
2717         auto animated_node = static_cast<scene::IAnimatedMeshSceneNode *>(node);
2718         float speed = animated_node->getAnimationSpeed();
2719         if (!speed)
2720                 return;
2721         paused.push_back({grab(animated_node), speed});
2722         animated_node->setAnimationSpeed(0.0f);
2723 }
2724
2725 void Game::pauseAnimation()
2726 {
2727         pauseNodeAnimation(paused_animated_nodes, smgr->getRootSceneNode());
2728 }
2729
2730 void Game::resumeAnimation()
2731 {
2732         for (auto &&pair: paused_animated_nodes)
2733                 pair.first->setAnimationSpeed(pair.second);
2734         paused_animated_nodes.clear();
2735 }
2736
2737 const ClientEventHandler Game::clientEventHandler[CLIENTEVENT_MAX] = {
2738         {&Game::handleClientEvent_None},
2739         {&Game::handleClientEvent_PlayerDamage},
2740         {&Game::handleClientEvent_PlayerForceMove},
2741         {&Game::handleClientEvent_Deathscreen},
2742         {&Game::handleClientEvent_ShowFormSpec},
2743         {&Game::handleClientEvent_ShowLocalFormSpec},
2744         {&Game::handleClientEvent_HandleParticleEvent},
2745         {&Game::handleClientEvent_HandleParticleEvent},
2746         {&Game::handleClientEvent_HandleParticleEvent},
2747         {&Game::handleClientEvent_HudAdd},
2748         {&Game::handleClientEvent_HudRemove},
2749         {&Game::handleClientEvent_HudChange},
2750         {&Game::handleClientEvent_SetSky},
2751         {&Game::handleClientEvent_SetSun},
2752         {&Game::handleClientEvent_SetMoon},
2753         {&Game::handleClientEvent_SetStars},
2754         {&Game::handleClientEvent_OverrideDayNigthRatio},
2755         {&Game::handleClientEvent_CloudParams},
2756 };
2757
2758 void Game::handleClientEvent_None(ClientEvent *event, CameraOrientation *cam)
2759 {
2760         FATAL_ERROR("ClientEvent type None received");
2761 }
2762
2763 void Game::handleClientEvent_PlayerDamage(ClientEvent *event, CameraOrientation *cam)
2764 {
2765         if (client->modsLoaded())
2766                 client->getScript()->on_damage_taken(event->player_damage.amount);
2767
2768         if (!event->player_damage.effect)
2769                 return;
2770
2771         // Damage flash and hurt tilt are not used at death
2772         if (client->getHP() > 0) {
2773                 LocalPlayer *player = client->getEnv().getLocalPlayer();
2774
2775                 f32 hp_max = player->getCAO() ?
2776                         player->getCAO()->getProperties().hp_max : PLAYER_MAX_HP_DEFAULT;
2777                 f32 damage_ratio = event->player_damage.amount / hp_max;
2778
2779                 runData.damage_flash += 95.0f + 64.f * damage_ratio;
2780                 runData.damage_flash = MYMIN(runData.damage_flash, 127.0f);
2781
2782                 player->hurt_tilt_timer = 1.5f;
2783                 player->hurt_tilt_strength =
2784                         rangelim(damage_ratio * 5.0f, 1.0f, 4.0f);
2785         }
2786
2787         // Play damage sound
2788         client->getEventManager()->put(new SimpleTriggerEvent(MtEvent::PLAYER_DAMAGE));
2789 }
2790
2791 void Game::handleClientEvent_PlayerForceMove(ClientEvent *event, CameraOrientation *cam)
2792 {
2793         cam->camera_yaw = event->player_force_move.yaw;
2794         cam->camera_pitch = event->player_force_move.pitch;
2795 }
2796
2797 void Game::handleClientEvent_Deathscreen(ClientEvent *event, CameraOrientation *cam)
2798 {
2799         // If client scripting is enabled, deathscreen is handled by CSM code in
2800         // builtin/client/init.lua
2801         if (client->modsLoaded())
2802                 client->getScript()->on_death();
2803         else
2804                 showDeathFormspec();
2805
2806         /* Handle visualization */
2807         LocalPlayer *player = client->getEnv().getLocalPlayer();
2808         runData.damage_flash = 0;
2809         player->hurt_tilt_timer = 0;
2810         player->hurt_tilt_strength = 0;
2811 }
2812
2813 void Game::handleClientEvent_ShowFormSpec(ClientEvent *event, CameraOrientation *cam)
2814 {
2815         if (event->show_formspec.formspec->empty()) {
2816                 auto formspec = m_game_ui->getFormspecGUI();
2817                 if (formspec && (event->show_formspec.formname->empty()
2818                                 || *(event->show_formspec.formname) == m_game_ui->getFormspecName())) {
2819                         formspec->quitMenu();
2820                 }
2821         } else {
2822                 FormspecFormSource *fs_src =
2823                         new FormspecFormSource(*(event->show_formspec.formspec));
2824                 TextDestPlayerInventory *txt_dst =
2825                         new TextDestPlayerInventory(client, *(event->show_formspec.formname));
2826
2827                 auto *&formspec = m_game_ui->updateFormspec(*(event->show_formspec.formname));
2828                 GUIFormSpecMenu::create(formspec, client, m_rendering_engine->get_gui_env(),
2829                         &input->joystick, fs_src, txt_dst, client->getFormspecPrepend(), sound);
2830         }
2831
2832         delete event->show_formspec.formspec;
2833         delete event->show_formspec.formname;
2834 }
2835
2836 void Game::handleClientEvent_ShowLocalFormSpec(ClientEvent *event, CameraOrientation *cam)
2837 {
2838         FormspecFormSource *fs_src = new FormspecFormSource(*event->show_formspec.formspec);
2839         LocalFormspecHandler *txt_dst =
2840                 new LocalFormspecHandler(*event->show_formspec.formname, client);
2841         GUIFormSpecMenu::create(m_game_ui->getFormspecGUI(), client, m_rendering_engine->get_gui_env(),
2842                         &input->joystick, fs_src, txt_dst, client->getFormspecPrepend(), sound);
2843
2844         delete event->show_formspec.formspec;
2845         delete event->show_formspec.formname;
2846 }
2847
2848 void Game::handleClientEvent_HandleParticleEvent(ClientEvent *event,
2849                 CameraOrientation *cam)
2850 {
2851         LocalPlayer *player = client->getEnv().getLocalPlayer();
2852         client->getParticleManager()->handleParticleEvent(event, client, player);
2853 }
2854
2855 void Game::handleClientEvent_HudAdd(ClientEvent *event, CameraOrientation *cam)
2856 {
2857         LocalPlayer *player = client->getEnv().getLocalPlayer();
2858
2859         u32 server_id = event->hudadd->server_id;
2860         // ignore if we already have a HUD with that ID
2861         auto i = m_hud_server_to_client.find(server_id);
2862         if (i != m_hud_server_to_client.end()) {
2863                 delete event->hudadd;
2864                 return;
2865         }
2866
2867         HudElement *e = new HudElement;
2868         e->type   = static_cast<HudElementType>(event->hudadd->type);
2869         e->pos    = event->hudadd->pos;
2870         e->name   = event->hudadd->name;
2871         e->scale  = event->hudadd->scale;
2872         e->text   = event->hudadd->text;
2873         e->number = event->hudadd->number;
2874         e->item   = event->hudadd->item;
2875         e->dir    = event->hudadd->dir;
2876         e->align  = event->hudadd->align;
2877         e->offset = event->hudadd->offset;
2878         e->world_pos = event->hudadd->world_pos;
2879         e->size      = event->hudadd->size;
2880         e->z_index   = event->hudadd->z_index;
2881         e->text2     = event->hudadd->text2;
2882         e->style     = event->hudadd->style;
2883         m_hud_server_to_client[server_id] = player->addHud(e);
2884
2885         delete event->hudadd;
2886 }
2887
2888 void Game::handleClientEvent_HudRemove(ClientEvent *event, CameraOrientation *cam)
2889 {
2890         LocalPlayer *player = client->getEnv().getLocalPlayer();
2891
2892         auto i = m_hud_server_to_client.find(event->hudrm.id);
2893         if (i != m_hud_server_to_client.end()) {
2894                 HudElement *e = player->removeHud(i->second);
2895                 delete e;
2896                 m_hud_server_to_client.erase(i);
2897         }
2898
2899 }
2900
2901 void Game::handleClientEvent_HudChange(ClientEvent *event, CameraOrientation *cam)
2902 {
2903         LocalPlayer *player = client->getEnv().getLocalPlayer();
2904
2905         HudElement *e = nullptr;
2906
2907         auto i = m_hud_server_to_client.find(event->hudchange->id);
2908         if (i != m_hud_server_to_client.end()) {
2909                 e = player->getHud(i->second);
2910         }
2911
2912         if (e == nullptr) {
2913                 delete event->hudchange;
2914                 return;
2915         }
2916
2917 #define CASE_SET(statval, prop, dataprop) \
2918         case statval: \
2919                 e->prop = event->hudchange->dataprop; \
2920                 break
2921
2922         switch (event->hudchange->stat) {
2923                 CASE_SET(HUD_STAT_POS, pos, v2fdata);
2924
2925                 CASE_SET(HUD_STAT_NAME, name, sdata);
2926
2927                 CASE_SET(HUD_STAT_SCALE, scale, v2fdata);
2928
2929                 CASE_SET(HUD_STAT_TEXT, text, sdata);
2930
2931                 CASE_SET(HUD_STAT_NUMBER, number, data);
2932
2933                 CASE_SET(HUD_STAT_ITEM, item, data);
2934
2935                 CASE_SET(HUD_STAT_DIR, dir, data);
2936
2937                 CASE_SET(HUD_STAT_ALIGN, align, v2fdata);
2938
2939                 CASE_SET(HUD_STAT_OFFSET, offset, v2fdata);
2940
2941                 CASE_SET(HUD_STAT_WORLD_POS, world_pos, v3fdata);
2942
2943                 CASE_SET(HUD_STAT_SIZE, size, v2s32data);
2944
2945                 CASE_SET(HUD_STAT_Z_INDEX, z_index, data);
2946
2947                 CASE_SET(HUD_STAT_TEXT2, text2, sdata);
2948
2949                 CASE_SET(HUD_STAT_STYLE, style, data);
2950         }
2951
2952 #undef CASE_SET
2953
2954         delete event->hudchange;
2955 }
2956
2957 void Game::handleClientEvent_SetSky(ClientEvent *event, CameraOrientation *cam)
2958 {
2959         sky->setVisible(false);
2960         // Whether clouds are visible in front of a custom skybox.
2961         sky->setCloudsEnabled(event->set_sky->clouds);
2962
2963         if (skybox) {
2964                 skybox->remove();
2965                 skybox = NULL;
2966         }
2967         // Clear the old textures out in case we switch rendering type.
2968         sky->clearSkyboxTextures();
2969         // Handle according to type
2970         if (event->set_sky->type == "regular") {
2971                 // Shows the mesh skybox
2972                 sky->setVisible(true);
2973                 // Update mesh based skybox colours if applicable.
2974                 sky->setSkyColors(event->set_sky->sky_color);
2975                 sky->setHorizonTint(
2976                         event->set_sky->fog_sun_tint,
2977                         event->set_sky->fog_moon_tint,
2978                         event->set_sky->fog_tint_type
2979                 );
2980         } else if (event->set_sky->type == "skybox" &&
2981                         event->set_sky->textures.size() == 6) {
2982                 // Disable the dyanmic mesh skybox:
2983                 sky->setVisible(false);
2984                 // Set fog colors:
2985                 sky->setFallbackBgColor(event->set_sky->bgcolor);
2986                 // Set sunrise and sunset fog tinting:
2987                 sky->setHorizonTint(
2988                         event->set_sky->fog_sun_tint,
2989                         event->set_sky->fog_moon_tint,
2990                         event->set_sky->fog_tint_type
2991                 );
2992                 // Add textures to skybox.
2993                 for (int i = 0; i < 6; i++)
2994                         sky->addTextureToSkybox(event->set_sky->textures[i], i, texture_src);
2995         } else {
2996                 // Handle everything else as plain color.
2997                 if (event->set_sky->type != "plain")
2998                         infostream << "Unknown sky type: "
2999                                 << (event->set_sky->type) << std::endl;
3000                 sky->setVisible(false);
3001                 sky->setFallbackBgColor(event->set_sky->bgcolor);
3002                 // Disable directional sun/moon tinting on plain or invalid skyboxes.
3003                 sky->setHorizonTint(
3004                         event->set_sky->bgcolor,
3005                         event->set_sky->bgcolor,
3006                         "custom"
3007                 );
3008         }
3009
3010         // Orbit Tilt:
3011         sky->setBodyOrbitTilt(event->set_sky->body_orbit_tilt);
3012
3013         delete event->set_sky;
3014 }
3015
3016 void Game::handleClientEvent_SetSun(ClientEvent *event, CameraOrientation *cam)
3017 {
3018         sky->setSunVisible(event->sun_params->visible);
3019         sky->setSunTexture(event->sun_params->texture,
3020                 event->sun_params->tonemap, texture_src);
3021         sky->setSunScale(event->sun_params->scale);
3022         sky->setSunriseVisible(event->sun_params->sunrise_visible);
3023         sky->setSunriseTexture(event->sun_params->sunrise, texture_src);
3024         delete event->sun_params;
3025 }
3026
3027 void Game::handleClientEvent_SetMoon(ClientEvent *event, CameraOrientation *cam)
3028 {
3029         sky->setMoonVisible(event->moon_params->visible);
3030         sky->setMoonTexture(event->moon_params->texture,
3031                 event->moon_params->tonemap, texture_src);
3032         sky->setMoonScale(event->moon_params->scale);
3033         delete event->moon_params;
3034 }
3035
3036 void Game::handleClientEvent_SetStars(ClientEvent *event, CameraOrientation *cam)
3037 {
3038         sky->setStarsVisible(event->star_params->visible);
3039         sky->setStarCount(event->star_params->count);
3040         sky->setStarColor(event->star_params->starcolor);
3041         sky->setStarScale(event->star_params->scale);
3042         sky->setStarDayOpacity(event->star_params->day_opacity);
3043         delete event->star_params;
3044 }
3045
3046 void Game::handleClientEvent_OverrideDayNigthRatio(ClientEvent *event,
3047                 CameraOrientation *cam)
3048 {
3049         client->getEnv().setDayNightRatioOverride(
3050                 event->override_day_night_ratio.do_override,
3051                 event->override_day_night_ratio.ratio_f * 1000.0f);
3052 }
3053
3054 void Game::handleClientEvent_CloudParams(ClientEvent *event, CameraOrientation *cam)
3055 {
3056         if (!clouds)
3057                 return;
3058
3059         clouds->setDensity(event->cloud_params.density);
3060         clouds->setColorBright(video::SColor(event->cloud_params.color_bright));
3061         clouds->setColorAmbient(video::SColor(event->cloud_params.color_ambient));
3062         clouds->setHeight(event->cloud_params.height);
3063         clouds->setThickness(event->cloud_params.thickness);
3064         clouds->setSpeed(v2f(event->cloud_params.speed_x, event->cloud_params.speed_y));
3065 }
3066
3067 void Game::processClientEvents(CameraOrientation *cam)
3068 {
3069         while (client->hasClientEvents()) {
3070                 std::unique_ptr<ClientEvent> event(client->getClientEvent());
3071                 FATAL_ERROR_IF(event->type >= CLIENTEVENT_MAX, "Invalid clientevent type");
3072                 const ClientEventHandler& evHandler = clientEventHandler[event->type];
3073                 (this->*evHandler.handler)(event.get(), cam);
3074         }
3075 }
3076
3077 void Game::updateChat(f32 dtime)
3078 {
3079         // Get new messages from error log buffer
3080         while (!m_chat_log_buf.empty())
3081                 chat_backend->addMessage(L"", utf8_to_wide(m_chat_log_buf.get()));
3082
3083         // Get new messages from client
3084         std::wstring message;
3085         while (client->getChatMessage(message)) {
3086                 chat_backend->addUnparsedMessage(message);
3087         }
3088
3089         // Remove old messages
3090         chat_backend->step(dtime);
3091
3092         // Display all messages in a static text element
3093         auto &buf = chat_backend->getRecentBuffer();
3094         if (buf.getLinesModified()) {
3095                 buf.resetLinesModified();
3096                 m_game_ui->setChatText(chat_backend->getRecentChat(), buf.getLineCount());
3097         }
3098
3099         // Make sure that the size is still correct
3100         m_game_ui->updateChatSize();
3101 }
3102
3103 void Game::updateCamera(f32 dtime)
3104 {
3105         LocalPlayer *player = client->getEnv().getLocalPlayer();
3106
3107         /*
3108                 For interaction purposes, get info about the held item
3109                 - What item is it?
3110                 - Is it a usable item?
3111                 - Can it point to liquids?
3112         */
3113         ItemStack playeritem;
3114         {
3115                 ItemStack selected, hand;
3116                 playeritem = player->getWieldedItem(&selected, &hand);
3117         }
3118
3119         ToolCapabilities playeritem_toolcap =
3120                 playeritem.getToolCapabilities(itemdef_manager);
3121
3122         v3s16 old_camera_offset = camera->getOffset();
3123
3124         if (wasKeyDown(KeyType::CAMERA_MODE)) {
3125                 GenericCAO *playercao = player->getCAO();
3126
3127                 // If playercao not loaded, don't change camera
3128                 if (!playercao)
3129                         return;
3130
3131                 camera->toggleCameraMode();
3132
3133 #ifdef HAVE_TOUCHSCREENGUI
3134                 if (g_touchscreengui)
3135                         g_touchscreengui->setUseCrosshair(!isNoCrosshairAllowed());
3136 #endif
3137
3138                 // Make the player visible depending on camera mode.
3139                 playercao->updateMeshCulling();
3140                 playercao->setChildrenVisible(camera->getCameraMode() > CAMERA_MODE_FIRST);
3141         }
3142
3143         float full_punch_interval = playeritem_toolcap.full_punch_interval;
3144         float tool_reload_ratio = runData.time_from_last_punch / full_punch_interval;
3145
3146         tool_reload_ratio = MYMIN(tool_reload_ratio, 1.0);
3147         camera->update(player, dtime, tool_reload_ratio);
3148         camera->step(dtime);
3149
3150         f32 camera_fov = camera->getFovMax();
3151         v3s16 camera_offset = camera->getOffset();
3152
3153         m_camera_offset_changed = (camera_offset != old_camera_offset);
3154
3155         if (!m_flags.disable_camera_update) {
3156                 v3f camera_position = camera->getPosition();
3157                 v3f camera_direction = camera->getDirection();
3158
3159                 client->getEnv().getClientMap().updateCamera(camera_position,
3160                                 camera_direction, camera_fov, camera_offset);
3161
3162                 if (m_camera_offset_changed) {
3163                         client->updateCameraOffset(camera_offset);
3164                         client->getEnv().updateCameraOffset(camera_offset);
3165
3166                         if (clouds)
3167                                 clouds->updateCameraOffset(camera_offset);
3168                 }
3169         }
3170 }
3171
3172
3173 void Game::updateSound(f32 dtime)
3174 {
3175         // Update sound listener
3176         v3s16 camera_offset = camera->getOffset();
3177         sound->updateListener(camera->getCameraNode()->getPosition() + intToFloat(camera_offset, BS),
3178                               v3f(0, 0, 0), // velocity
3179                               camera->getDirection(),
3180                               camera->getCameraNode()->getUpVector());
3181
3182         bool mute_sound = g_settings->getBool("mute_sound");
3183         if (mute_sound) {
3184                 sound->setListenerGain(0.0f);
3185         } else {
3186                 // Check if volume is in the proper range, else fix it.
3187                 float old_volume = g_settings->getFloat("sound_volume");
3188                 float new_volume = rangelim(old_volume, 0.0f, 1.0f);
3189                 sound->setListenerGain(new_volume);
3190
3191                 if (old_volume != new_volume) {
3192                         g_settings->setFloat("sound_volume", new_volume);
3193                 }
3194         }
3195
3196         LocalPlayer *player = client->getEnv().getLocalPlayer();
3197
3198         // Tell the sound maker whether to make footstep sounds
3199         soundmaker->makes_footstep_sound = player->makes_footstep_sound;
3200
3201         //      Update sound maker
3202         if (player->makes_footstep_sound)
3203                 soundmaker->step(dtime);
3204
3205         ClientMap &map = client->getEnv().getClientMap();
3206         MapNode n = map.getNode(player->getFootstepNodePos());
3207         soundmaker->m_player_step_sound = nodedef_manager->get(n).sound_footstep;
3208 }
3209
3210
3211 void Game::processPlayerInteraction(f32 dtime, bool show_hud)
3212 {
3213         LocalPlayer *player = client->getEnv().getLocalPlayer();
3214
3215         const v3f camera_direction = camera->getDirection();
3216         const v3s16 camera_offset  = camera->getOffset();
3217
3218         /*
3219                 Calculate what block is the crosshair pointing to
3220         */
3221
3222         ItemStack selected_item, hand_item;
3223         const ItemStack &tool_item = player->getWieldedItem(&selected_item, &hand_item);
3224
3225         const ItemDefinition &selected_def = selected_item.getDefinition(itemdef_manager);
3226         f32 d = getToolRange(selected_def, hand_item.getDefinition(itemdef_manager));
3227
3228         core::line3d<f32> shootline;
3229
3230         switch (camera->getCameraMode()) {
3231         case CAMERA_MODE_FIRST:
3232                 // Shoot from camera position, with bobbing
3233                 shootline.start = camera->getPosition();
3234                 break;
3235         case CAMERA_MODE_THIRD:
3236                 // Shoot from player head, no bobbing
3237                 shootline.start = camera->getHeadPosition();
3238                 break;
3239         case CAMERA_MODE_THIRD_FRONT:
3240                 shootline.start = camera->getHeadPosition();
3241                 // prevent player pointing anything in front-view
3242                 d = 0;
3243                 break;
3244         }
3245         shootline.end = shootline.start + camera_direction * BS * d;
3246
3247 #ifdef HAVE_TOUCHSCREENGUI
3248         if (g_touchscreengui && isNoCrosshairAllowed()) {
3249                 shootline = g_touchscreengui->getShootline();
3250                 // Scale shootline to the acual distance the player can reach
3251                 shootline.end = shootline.start +
3252                                 shootline.getVector().normalize() * BS * d;
3253                 shootline.start += intToFloat(camera_offset, BS);
3254                 shootline.end += intToFloat(camera_offset, BS);
3255         }
3256 #endif
3257
3258         PointedThing pointed = updatePointedThing(shootline,
3259                         selected_def.liquids_pointable,
3260                         !runData.btn_down_for_dig,
3261                         camera_offset);
3262
3263         if (pointed != runData.pointed_old)
3264                 infostream << "Pointing at " << pointed.dump() << std::endl;
3265
3266         // Note that updating the selection mesh every frame is not particularly efficient,
3267         // but the halo rendering code is already inefficient so there's no point in optimizing it here
3268         hud->updateSelectionMesh(camera_offset);
3269
3270         // Allow digging again if button is not pressed
3271         if (runData.digging_blocked && !isKeyDown(KeyType::DIG))
3272                 runData.digging_blocked = false;
3273
3274         /*
3275                 Stop digging when
3276                 - releasing dig button
3277                 - pointing away from node
3278         */
3279         if (runData.digging) {
3280                 if (wasKeyReleased(KeyType::DIG)) {
3281                         infostream << "Dig button released (stopped digging)" << std::endl;
3282                         runData.digging = false;
3283                 } else if (pointed != runData.pointed_old) {
3284                         if (pointed.type == POINTEDTHING_NODE
3285                                         && runData.pointed_old.type == POINTEDTHING_NODE
3286                                         && pointed.node_undersurface
3287                                                         == runData.pointed_old.node_undersurface) {
3288                                 // Still pointing to the same node, but a different face.
3289                                 // Don't reset.
3290                         } else {
3291                                 infostream << "Pointing away from node (stopped digging)" << std::endl;
3292                                 runData.digging = false;
3293                                 hud->updateSelectionMesh(camera_offset);
3294                         }
3295                 }
3296
3297                 if (!runData.digging) {
3298                         client->interact(INTERACT_STOP_DIGGING, runData.pointed_old);
3299                         client->setCrack(-1, v3s16(0, 0, 0));
3300                         runData.dig_time = 0.0;
3301                 }
3302         } else if (runData.dig_instantly && wasKeyReleased(KeyType::DIG)) {
3303                 // Remove e.g. torches faster when clicking instead of holding dig button
3304                 runData.nodig_delay_timer = 0;
3305                 runData.dig_instantly = false;
3306         }
3307
3308         if (!runData.digging && runData.btn_down_for_dig && !isKeyDown(KeyType::DIG))
3309                 runData.btn_down_for_dig = false;
3310
3311         runData.punching = false;
3312
3313         soundmaker->m_player_leftpunch_sound = SimpleSoundSpec();
3314         soundmaker->m_player_leftpunch_sound2 = pointed.type != POINTEDTHING_NOTHING ?
3315                 selected_def.sound_use : selected_def.sound_use_air;
3316
3317         // Prepare for repeating, unless we're not supposed to
3318         if (isKeyDown(KeyType::PLACE) && !g_settings->getBool("safe_dig_and_place"))
3319                 runData.repeat_place_timer += dtime;
3320         else
3321                 runData.repeat_place_timer = 0;
3322
3323         if (selected_def.usable && isKeyDown(KeyType::DIG)) {
3324                 if (wasKeyPressed(KeyType::DIG) && (!client->modsLoaded() ||
3325                                 !client->getScript()->on_item_use(selected_item, pointed)))
3326                         client->interact(INTERACT_USE, pointed);
3327         } else if (pointed.type == POINTEDTHING_NODE) {
3328                 handlePointingAtNode(pointed, selected_item, hand_item, dtime);
3329         } else if (pointed.type == POINTEDTHING_OBJECT) {
3330                 v3f player_position  = player->getPosition();
3331                 bool basic_debug_allowed = client->checkPrivilege("debug") || (player->hud_flags & HUD_FLAG_BASIC_DEBUG);
3332                 handlePointingAtObject(pointed, tool_item, player_position,
3333                                 m_game_ui->m_flags.show_basic_debug && basic_debug_allowed);
3334         } else if (isKeyDown(KeyType::DIG)) {
3335                 // When button is held down in air, show continuous animation
3336                 runData.punching = true;
3337                 // Run callback even though item is not usable
3338                 if (wasKeyPressed(KeyType::DIG) && client->modsLoaded())
3339                         client->getScript()->on_item_use(selected_item, pointed);
3340         } else if (wasKeyPressed(KeyType::PLACE)) {
3341                 handlePointingAtNothing(selected_item);
3342         }
3343
3344         runData.pointed_old = pointed;
3345
3346         if (runData.punching || wasKeyPressed(KeyType::DIG))
3347                 camera->setDigging(0); // dig animation
3348
3349         input->clearWasKeyPressed();
3350         input->clearWasKeyReleased();
3351         // Ensure DIG & PLACE are marked as handled
3352         wasKeyDown(KeyType::DIG);
3353         wasKeyDown(KeyType::PLACE);
3354
3355         input->joystick.clearWasKeyPressed(KeyType::DIG);
3356         input->joystick.clearWasKeyPressed(KeyType::PLACE);
3357
3358         input->joystick.clearWasKeyReleased(KeyType::DIG);
3359         input->joystick.clearWasKeyReleased(KeyType::PLACE);
3360 }
3361
3362
3363 PointedThing Game::updatePointedThing(
3364         const core::line3d<f32> &shootline,
3365         bool liquids_pointable,
3366         bool look_for_object,
3367         const v3s16 &camera_offset)
3368 {
3369         std::vector<aabb3f> *selectionboxes = hud->getSelectionBoxes();
3370         selectionboxes->clear();
3371         hud->setSelectedFaceNormal(v3f());
3372         static thread_local const bool show_entity_selectionbox = g_settings->getBool(
3373                 "show_entity_selectionbox");
3374
3375         ClientEnvironment &env = client->getEnv();
3376         ClientMap &map = env.getClientMap();
3377         const NodeDefManager *nodedef = map.getNodeDefManager();
3378
3379         runData.selected_object = NULL;
3380         hud->pointing_at_object = false;
3381
3382         RaycastState s(shootline, look_for_object, liquids_pointable);
3383         PointedThing result;
3384         env.continueRaycast(&s, &result);
3385         if (result.type == POINTEDTHING_OBJECT) {
3386                 hud->pointing_at_object = true;
3387
3388                 runData.selected_object = client->getEnv().getActiveObject(result.object_id);
3389                 aabb3f selection_box;
3390                 if (show_entity_selectionbox && runData.selected_object->doShowSelectionBox() &&
3391                                 runData.selected_object->getSelectionBox(&selection_box)) {
3392                         v3f pos = runData.selected_object->getPosition();
3393                         selectionboxes->push_back(aabb3f(selection_box));
3394                         hud->setSelectionPos(pos, camera_offset);
3395                         GenericCAO* gcao = dynamic_cast<GenericCAO*>(runData.selected_object);
3396                         if (gcao != nullptr && gcao->getProperties().rotate_selectionbox)
3397                                 hud->setSelectionRotation(gcao->getSceneNode()->getAbsoluteTransformation().getRotationDegrees());
3398                         else
3399                                 hud->setSelectionRotation(v3f());
3400                 }
3401                 hud->setSelectedFaceNormal(result.raw_intersection_normal);
3402         } else if (result.type == POINTEDTHING_NODE) {
3403                 // Update selection boxes
3404                 MapNode n = map.getNode(result.node_undersurface);
3405                 std::vector<aabb3f> boxes;
3406                 n.getSelectionBoxes(nodedef, &boxes,
3407                         n.getNeighbors(result.node_undersurface, &map));
3408
3409                 f32 d = 0.002 * BS;
3410                 for (std::vector<aabb3f>::const_iterator i = boxes.begin();
3411                         i != boxes.end(); ++i) {
3412                         aabb3f box = *i;
3413                         box.MinEdge -= v3f(d, d, d);
3414                         box.MaxEdge += v3f(d, d, d);
3415                         selectionboxes->push_back(box);
3416                 }
3417                 hud->setSelectionPos(intToFloat(result.node_undersurface, BS),
3418                         camera_offset);
3419                 hud->setSelectionRotation(v3f());
3420                 hud->setSelectedFaceNormal(result.intersection_normal);
3421         }
3422
3423         // Update selection mesh light level and vertex colors
3424         if (!selectionboxes->empty()) {
3425                 v3f pf = hud->getSelectionPos();
3426                 v3s16 p = floatToInt(pf, BS);
3427
3428                 // Get selection mesh light level
3429                 MapNode n = map.getNode(p);
3430                 u16 node_light = getInteriorLight(n, -1, nodedef);
3431                 u16 light_level = node_light;
3432
3433                 for (const v3s16 &dir : g_6dirs) {
3434                         n = map.getNode(p + dir);
3435                         node_light = getInteriorLight(n, -1, nodedef);
3436                         if (node_light > light_level)
3437                                 light_level = node_light;
3438                 }
3439
3440                 u32 daynight_ratio = client->getEnv().getDayNightRatio();
3441                 video::SColor c;
3442                 final_color_blend(&c, light_level, daynight_ratio);
3443
3444                 // Modify final color a bit with time
3445                 u32 timer = client->getEnv().getFrameTime() % 5000;
3446                 float timerf = (float) (irr::core::PI * ((timer / 2500.0) - 0.5));
3447                 float sin_r = 0.08f * std::sin(timerf);
3448                 float sin_g = 0.08f * std::sin(timerf + irr::core::PI * 0.5f);
3449                 float sin_b = 0.08f * std::sin(timerf + irr::core::PI);
3450                 c.setRed(core::clamp(core::round32(c.getRed() * (0.8 + sin_r)), 0, 255));
3451                 c.setGreen(core::clamp(core::round32(c.getGreen() * (0.8 + sin_g)), 0, 255));
3452                 c.setBlue(core::clamp(core::round32(c.getBlue() * (0.8 + sin_b)), 0, 255));
3453
3454                 // Set mesh final color
3455                 hud->setSelectionMeshColor(c);
3456         }
3457         return result;
3458 }
3459
3460
3461 void Game::handlePointingAtNothing(const ItemStack &playerItem)
3462 {
3463         infostream << "Attempted to place item while pointing at nothing" << std::endl;
3464         PointedThing fauxPointed;
3465         fauxPointed.type = POINTEDTHING_NOTHING;
3466         client->interact(INTERACT_ACTIVATE, fauxPointed);
3467 }
3468
3469
3470 void Game::handlePointingAtNode(const PointedThing &pointed,
3471         const ItemStack &selected_item, const ItemStack &hand_item, f32 dtime)
3472 {
3473         v3s16 nodepos = pointed.node_undersurface;
3474         v3s16 neighborpos = pointed.node_abovesurface;
3475
3476         /*
3477                 Check information text of node
3478         */
3479
3480         ClientMap &map = client->getEnv().getClientMap();
3481
3482         if (runData.nodig_delay_timer <= 0.0 && isKeyDown(KeyType::DIG)
3483                         && !runData.digging_blocked
3484                         && client->checkPrivilege("interact")) {
3485                 handleDigging(pointed, nodepos, selected_item, hand_item, dtime);
3486         }
3487
3488         // This should be done after digging handling
3489         NodeMetadata *meta = map.getNodeMetadata(nodepos);
3490
3491         if (meta) {
3492                 m_game_ui->setInfoText(unescape_translate(utf8_to_wide(
3493                         meta->getString("infotext"))));
3494         } else {
3495                 MapNode n = map.getNode(nodepos);
3496
3497                 if (nodedef_manager->get(n).name == "unknown") {
3498                         m_game_ui->setInfoText(L"Unknown node");
3499                 }
3500         }
3501
3502         if ((wasKeyPressed(KeyType::PLACE) ||
3503                         runData.repeat_place_timer >= m_repeat_place_time) &&
3504                         client->checkPrivilege("interact")) {
3505                 runData.repeat_place_timer = 0;
3506                 infostream << "Place button pressed while looking at ground" << std::endl;
3507
3508                 // Placing animation (always shown for feedback)
3509                 camera->setDigging(1);
3510
3511                 soundmaker->m_player_rightpunch_sound = SimpleSoundSpec();
3512
3513                 // If the wielded item has node placement prediction,
3514                 // make that happen
3515                 // And also set the sound and send the interact
3516                 // But first check for meta formspec and rightclickable
3517                 auto &def = selected_item.getDefinition(itemdef_manager);
3518                 bool placed = nodePlacement(def, selected_item, nodepos, neighborpos,
3519                         pointed, meta);
3520
3521                 if (placed && client->modsLoaded())
3522                         client->getScript()->on_placenode(pointed, def);
3523         }
3524 }
3525
3526 bool Game::nodePlacement(const ItemDefinition &selected_def,
3527         const ItemStack &selected_item, const v3s16 &nodepos, const v3s16 &neighborpos,
3528         const PointedThing &pointed, const NodeMetadata *meta)
3529 {
3530         const auto &prediction = selected_def.node_placement_prediction;
3531
3532         const NodeDefManager *nodedef = client->ndef();
3533         ClientMap &map = client->getEnv().getClientMap();
3534         MapNode node;
3535         bool is_valid_position;
3536
3537         node = map.getNode(nodepos, &is_valid_position);
3538         if (!is_valid_position) {
3539                 soundmaker->m_player_rightpunch_sound = selected_def.sound_place_failed;
3540                 return false;
3541         }
3542
3543         // formspec in meta
3544         if (meta && !meta->getString("formspec").empty() && !input->isRandom()
3545                         && !isKeyDown(KeyType::SNEAK)) {
3546                 // on_rightclick callbacks are called anyway
3547                 if (nodedef_manager->get(map.getNode(nodepos)).rightclickable)
3548                         client->interact(INTERACT_PLACE, pointed);
3549
3550                 infostream << "Launching custom inventory view" << std::endl;
3551
3552                 InventoryLocation inventoryloc;
3553                 inventoryloc.setNodeMeta(nodepos);
3554
3555                 NodeMetadataFormSource *fs_src = new NodeMetadataFormSource(
3556                         &client->getEnv().getClientMap(), nodepos);
3557                 TextDest *txt_dst = new TextDestNodeMetadata(nodepos, client);
3558
3559                 auto *&formspec = m_game_ui->updateFormspec("");
3560                 GUIFormSpecMenu::create(formspec, client, m_rendering_engine->get_gui_env(),
3561                         &input->joystick, fs_src, txt_dst, client->getFormspecPrepend(), sound);
3562
3563                 formspec->setFormSpec(meta->getString("formspec"), inventoryloc);
3564                 return false;
3565         }
3566
3567         // on_rightclick callback
3568         if (prediction.empty() || (nodedef->get(node).rightclickable &&
3569                         !isKeyDown(KeyType::SNEAK))) {
3570                 // Report to server
3571                 client->interact(INTERACT_PLACE, pointed);
3572                 return false;
3573         }
3574
3575         verbosestream << "Node placement prediction for "
3576                 << selected_def.name << " is " << prediction << std::endl;
3577         v3s16 p = neighborpos;
3578
3579         // Place inside node itself if buildable_to
3580         MapNode n_under = map.getNode(nodepos, &is_valid_position);
3581         if (is_valid_position) {
3582                 if (nodedef->get(n_under).buildable_to) {
3583                         p = nodepos;
3584                 } else {
3585                         node = map.getNode(p, &is_valid_position);
3586                         if (is_valid_position && !nodedef->get(node).buildable_to) {
3587                                 soundmaker->m_player_rightpunch_sound = selected_def.sound_place_failed;
3588                                 // Report to server
3589                                 client->interact(INTERACT_PLACE, pointed);
3590                                 return false;
3591                         }
3592                 }
3593         }
3594
3595         // Find id of predicted node
3596         content_t id;
3597         bool found = nodedef->getId(prediction, id);
3598
3599         if (!found) {
3600                 errorstream << "Node placement prediction failed for "
3601                         << selected_def.name << " (places " << prediction
3602                         << ") - Name not known" << std::endl;
3603                 // Handle this as if prediction was empty
3604                 // Report to server
3605                 client->interact(INTERACT_PLACE, pointed);
3606                 return false;
3607         }
3608
3609         const ContentFeatures &predicted_f = nodedef->get(id);
3610
3611         // Compare core.item_place_node() for what the server does with param2
3612         MapNode predicted_node(id, 0, 0);
3613
3614         const u8 place_param2 = selected_def.place_param2;
3615
3616         if (place_param2) {
3617                 predicted_node.setParam2(place_param2);
3618         } else if (predicted_f.param_type_2 == CPT2_WALLMOUNTED ||
3619                         predicted_f.param_type_2 == CPT2_COLORED_WALLMOUNTED) {
3620                 v3s16 dir = nodepos - neighborpos;
3621
3622                 if (abs(dir.Y) > MYMAX(abs(dir.X), abs(dir.Z))) {
3623                         predicted_node.setParam2(dir.Y < 0 ? 1 : 0);
3624                 } else if (abs(dir.X) > abs(dir.Z)) {
3625                         predicted_node.setParam2(dir.X < 0 ? 3 : 2);
3626                 } else {
3627                         predicted_node.setParam2(dir.Z < 0 ? 5 : 4);
3628                 }
3629         } else if (predicted_f.param_type_2 == CPT2_FACEDIR ||
3630                         predicted_f.param_type_2 == CPT2_COLORED_FACEDIR ||
3631                         predicted_f.param_type_2 == CPT2_4DIR ||
3632                         predicted_f.param_type_2 == CPT2_COLORED_4DIR) {
3633                 v3s16 dir = nodepos - floatToInt(client->getEnv().getLocalPlayer()->getPosition(), BS);
3634
3635                 if (abs(dir.X) > abs(dir.Z)) {
3636                         predicted_node.setParam2(dir.X < 0 ? 3 : 1);
3637                 } else {
3638                         predicted_node.setParam2(dir.Z < 0 ? 2 : 0);
3639                 }
3640         }
3641
3642         // Check attachment if node is in group attached_node
3643         int an = itemgroup_get(predicted_f.groups, "attached_node");
3644         if (an != 0) {
3645                 v3s16 pp;
3646
3647                 if (an == 3) {
3648                         pp = p + v3s16(0, -1, 0);
3649                 } else if (an == 4) {
3650                         pp = p + v3s16(0, 1, 0);
3651                 } else if (an == 2) {
3652                         if (predicted_f.param_type_2 == CPT2_FACEDIR ||
3653                                         predicted_f.param_type_2 == CPT2_COLORED_FACEDIR ||
3654                                         predicted_f.param_type_2 == CPT2_4DIR ||
3655                                         predicted_f.param_type_2 == CPT2_COLORED_4DIR) {
3656                                 pp = p + facedir_dirs[predicted_node.getFaceDir(nodedef)];
3657                         } else {
3658                                 pp = p;
3659                         }
3660                 } else if (predicted_f.param_type_2 == CPT2_WALLMOUNTED ||
3661                                 predicted_f.param_type_2 == CPT2_COLORED_WALLMOUNTED) {
3662                         pp = p + predicted_node.getWallMountedDir(nodedef);
3663                 } else {
3664                         pp = p + v3s16(0, -1, 0);
3665                 }
3666
3667                 if (!nodedef->get(map.getNode(pp)).walkable) {
3668                         soundmaker->m_player_rightpunch_sound = selected_def.sound_place_failed;
3669                         // Report to server
3670                         client->interact(INTERACT_PLACE, pointed);
3671                         return false;
3672                 }
3673         }
3674
3675         // Apply color
3676         if (!place_param2 && (predicted_f.param_type_2 == CPT2_COLOR
3677                         || predicted_f.param_type_2 == CPT2_COLORED_FACEDIR
3678                         || predicted_f.param_type_2 == CPT2_COLORED_4DIR
3679                         || predicted_f.param_type_2 == CPT2_COLORED_WALLMOUNTED)) {
3680                 const auto &indexstr = selected_item.metadata.
3681                         getString("palette_index", 0);
3682                 if (!indexstr.empty()) {
3683                         s32 index = mystoi(indexstr);
3684                         if (predicted_f.param_type_2 == CPT2_COLOR) {
3685                                 predicted_node.setParam2(index);
3686                         } else if (predicted_f.param_type_2 == CPT2_COLORED_WALLMOUNTED) {
3687                                 // param2 = pure palette index + other
3688                                 predicted_node.setParam2((index & 0xf8) | (predicted_node.getParam2() & 0x07));
3689                         } else if (predicted_f.param_type_2 == CPT2_COLORED_FACEDIR) {
3690                                 // param2 = pure palette index + other
3691                                 predicted_node.setParam2((index & 0xe0) | (predicted_node.getParam2() & 0x1f));
3692                         } else if (predicted_f.param_type_2 == CPT2_COLORED_4DIR) {
3693                                 // param2 = pure palette index + other
3694                                 predicted_node.setParam2((index & 0xfc) | (predicted_node.getParam2() & 0x03));
3695                         }
3696                 }
3697         }
3698
3699         // Add node to client map
3700         try {
3701                 LocalPlayer *player = client->getEnv().getLocalPlayer();
3702
3703                 // Don't place node when player would be inside new node
3704                 // NOTE: This is to be eventually implemented by a mod as client-side Lua
3705                 if (!predicted_f.walkable ||
3706                                 g_settings->getBool("enable_build_where_you_stand") ||
3707                                 (client->checkPrivilege("noclip") && g_settings->getBool("noclip")) ||
3708                                 (predicted_f.walkable &&
3709                                         neighborpos != player->getStandingNodePos() + v3s16(0, 1, 0) &&
3710                                         neighborpos != player->getStandingNodePos() + v3s16(0, 2, 0))) {
3711                         // This triggers the required mesh update too
3712                         client->addNode(p, predicted_node);
3713                         // Report to server
3714                         client->interact(INTERACT_PLACE, pointed);
3715                         // A node is predicted, also play a sound
3716                         soundmaker->m_player_rightpunch_sound = selected_def.sound_place;
3717                         return true;
3718                 } else {
3719                         soundmaker->m_player_rightpunch_sound = selected_def.sound_place_failed;
3720                         return false;
3721                 }
3722         } catch (const InvalidPositionException &e) {
3723                 errorstream << "Node placement prediction failed for "
3724                         << selected_def.name << " (places "
3725                         << prediction << ") - Position not loaded" << std::endl;
3726                 soundmaker->m_player_rightpunch_sound = selected_def.sound_place_failed;
3727                 return false;
3728         }
3729 }
3730
3731 void Game::handlePointingAtObject(const PointedThing &pointed,
3732                 const ItemStack &tool_item, const v3f &player_position, bool show_debug)
3733 {
3734         std::wstring infotext = unescape_translate(
3735                 utf8_to_wide(runData.selected_object->infoText()));
3736
3737         if (show_debug) {
3738                 if (!infotext.empty()) {
3739                         infotext += L"\n";
3740                 }
3741                 infotext += utf8_to_wide(runData.selected_object->debugInfoText());
3742         }
3743
3744         m_game_ui->setInfoText(infotext);
3745
3746         if (isKeyDown(KeyType::DIG)) {
3747                 bool do_punch = false;
3748                 bool do_punch_damage = false;
3749
3750                 if (runData.object_hit_delay_timer <= 0.0) {
3751                         do_punch = true;
3752                         do_punch_damage = true;
3753                         runData.object_hit_delay_timer = object_hit_delay;
3754                 }
3755
3756                 if (wasKeyPressed(KeyType::DIG))
3757                         do_punch = true;
3758
3759                 if (do_punch) {
3760                         infostream << "Punched object" << std::endl;
3761                         runData.punching = true;
3762                 }
3763
3764                 if (do_punch_damage) {
3765                         // Report direct punch
3766                         v3f objpos = runData.selected_object->getPosition();
3767                         v3f dir = (objpos - player_position).normalize();
3768
3769                         bool disable_send = runData.selected_object->directReportPunch(
3770                                         dir, &tool_item, runData.time_from_last_punch);
3771                         runData.time_from_last_punch = 0;
3772
3773                         if (!disable_send)
3774                                 client->interact(INTERACT_START_DIGGING, pointed);
3775                 }
3776         } else if (wasKeyDown(KeyType::PLACE)) {
3777                 infostream << "Pressed place button while pointing at object" << std::endl;
3778                 client->interact(INTERACT_PLACE, pointed);  // place
3779         }
3780 }
3781
3782
3783 void Game::handleDigging(const PointedThing &pointed, const v3s16 &nodepos,
3784                 const ItemStack &selected_item, const ItemStack &hand_item, f32 dtime)
3785 {
3786         // See also: serverpackethandle.cpp, action == 2
3787         LocalPlayer *player = client->getEnv().getLocalPlayer();
3788         ClientMap &map = client->getEnv().getClientMap();
3789         MapNode n = map.getNode(nodepos);
3790         const auto &features = nodedef_manager->get(n);
3791
3792         // NOTE: Similar piece of code exists on the server side for
3793         // cheat detection.
3794         // Get digging parameters
3795         DigParams params = getDigParams(features.groups,
3796                         &selected_item.getToolCapabilities(itemdef_manager),
3797                         selected_item.wear);
3798
3799         // If can't dig, try hand
3800         if (!params.diggable) {
3801                 params = getDigParams(features.groups,
3802                                 &hand_item.getToolCapabilities(itemdef_manager));
3803         }
3804
3805         if (!params.diggable) {
3806                 // I guess nobody will wait for this long
3807                 runData.dig_time_complete = 10000000.0;
3808         } else {
3809                 runData.dig_time_complete = params.time;
3810
3811                 if (m_cache_enable_particles) {
3812                         client->getParticleManager()->addNodeParticle(client,
3813                                         player, nodepos, n, features);
3814                 }
3815         }
3816
3817         if (!runData.digging) {
3818                 infostream << "Started digging" << std::endl;
3819                 runData.dig_instantly = runData.dig_time_complete == 0;
3820                 if (client->modsLoaded() && client->getScript()->on_punchnode(nodepos, n))
3821                         return;
3822
3823                 client->interact(INTERACT_START_DIGGING, pointed);
3824                 runData.digging = true;
3825                 runData.btn_down_for_dig = true;
3826         }
3827
3828         if (!runData.dig_instantly) {
3829                 runData.dig_index = (float)crack_animation_length
3830                                 * runData.dig_time
3831                                 / runData.dig_time_complete;
3832         } else {
3833                 // This is for e.g. torches
3834                 runData.dig_index = crack_animation_length;
3835         }
3836
3837         const auto &sound_dig = features.sound_dig;
3838
3839         if (sound_dig.exists() && params.diggable) {
3840                 if (sound_dig.name == "__group") {
3841                         if (!params.main_group.empty()) {
3842                                 soundmaker->m_player_leftpunch_sound.gain = 0.5;
3843                                 soundmaker->m_player_leftpunch_sound.name =
3844                                                 std::string("default_dig_") +
3845                                                 params.main_group;
3846                         }
3847                 } else {
3848                         soundmaker->m_player_leftpunch_sound = sound_dig;
3849                 }
3850         }
3851
3852         // Don't show cracks if not diggable
3853         if (runData.dig_time_complete >= 100000.0) {
3854         } else if (runData.dig_index < crack_animation_length) {
3855                 client->setCrack(runData.dig_index, nodepos);
3856         } else {
3857                 infostream << "Digging completed" << std::endl;
3858                 client->setCrack(-1, v3s16(0, 0, 0));
3859
3860                 runData.dig_time = 0;
3861                 runData.digging = false;
3862                 // we successfully dug, now block it from repeating if we want to be safe
3863                 if (g_settings->getBool("safe_dig_and_place"))
3864                         runData.digging_blocked = true;
3865
3866                 runData.nodig_delay_timer =
3867                                 runData.dig_time_complete / (float)crack_animation_length;
3868
3869                 // We don't want a corresponding delay to very time consuming nodes
3870                 // and nodes without digging time (e.g. torches) get a fixed delay.
3871                 if (runData.nodig_delay_timer > 0.3)
3872                         runData.nodig_delay_timer = 0.3;
3873                 else if (runData.dig_instantly)
3874                         runData.nodig_delay_timer = 0.15;
3875
3876                 if (client->modsLoaded() &&
3877                                 client->getScript()->on_dignode(nodepos, n)) {
3878                         return;
3879                 }
3880
3881                 if (features.node_dig_prediction == "air") {
3882                         client->removeNode(nodepos);
3883                 } else if (!features.node_dig_prediction.empty()) {
3884                         content_t id;
3885                         bool found = nodedef_manager->getId(features.node_dig_prediction, id);
3886                         if (found)
3887                                 client->addNode(nodepos, id, true);
3888                 }
3889                 // implicit else: no prediction
3890
3891                 client->interact(INTERACT_DIGGING_COMPLETED, pointed);
3892
3893                 if (m_cache_enable_particles) {
3894                         client->getParticleManager()->addDiggingParticles(client,
3895                                 player, nodepos, n, features);
3896                 }
3897
3898
3899                 // Send event to trigger sound
3900                 client->getEventManager()->put(new NodeDugEvent(nodepos, n));
3901         }
3902
3903         if (runData.dig_time_complete < 100000.0) {
3904                 runData.dig_time += dtime;
3905         } else {
3906                 runData.dig_time = 0;
3907                 client->setCrack(-1, nodepos);
3908         }
3909
3910         camera->setDigging(0);  // Dig animation
3911 }
3912
3913 void Game::updateFrame(ProfilerGraph *graph, RunStats *stats, f32 dtime,
3914                 const CameraOrientation &cam)
3915 {
3916         TimeTaker tt_update("Game::updateFrame()");
3917         LocalPlayer *player = client->getEnv().getLocalPlayer();
3918
3919         /*
3920                 Frame time
3921         */
3922
3923         client->getEnv().updateFrameTime(m_is_paused);
3924
3925         /*
3926                 Fog range
3927         */
3928
3929         if (draw_control->range_all) {
3930                 runData.fog_range = 100000 * BS;
3931         } else {
3932                 runData.fog_range = draw_control->wanted_range * BS;
3933         }
3934
3935         /*
3936                 Calculate general brightness
3937         */
3938         u32 daynight_ratio = client->getEnv().getDayNightRatio();
3939         float time_brightness = decode_light_f((float)daynight_ratio / 1000.0);
3940         float direct_brightness;
3941         bool sunlight_seen;
3942
3943         // When in noclip mode force same sky brightness as above ground so you
3944         // can see properly
3945         if (draw_control->allow_noclip && m_cache_enable_free_move &&
3946                 client->checkPrivilege("fly")) {
3947                 direct_brightness = time_brightness;
3948                 sunlight_seen = true;
3949         } else {
3950                 float old_brightness = sky->getBrightness();
3951                 direct_brightness = client->getEnv().getClientMap()
3952                                 .getBackgroundBrightness(MYMIN(runData.fog_range * 1.2, 60 * BS),
3953                                         daynight_ratio, (int)(old_brightness * 255.5), &sunlight_seen)
3954                                     / 255.0;
3955         }
3956
3957         float time_of_day_smooth = runData.time_of_day_smooth;
3958         float time_of_day = client->getEnv().getTimeOfDayF();
3959
3960         static const float maxsm = 0.05f;
3961         static const float todsm = 0.05f;
3962
3963         if (std::fabs(time_of_day - time_of_day_smooth) > maxsm &&
3964                         std::fabs(time_of_day - time_of_day_smooth + 1.0) > maxsm &&
3965                         std::fabs(time_of_day - time_of_day_smooth - 1.0) > maxsm)
3966                 time_of_day_smooth = time_of_day;
3967
3968         if (time_of_day_smooth > 0.8 && time_of_day < 0.2)
3969                 time_of_day_smooth = time_of_day_smooth * (1.0 - todsm)
3970                                 + (time_of_day + 1.0) * todsm;
3971         else
3972                 time_of_day_smooth = time_of_day_smooth * (1.0 - todsm)
3973                                 + time_of_day * todsm;
3974
3975         runData.time_of_day_smooth = time_of_day_smooth;
3976
3977         sky->update(time_of_day_smooth, time_brightness, direct_brightness,
3978                         sunlight_seen, camera->getCameraMode(), player->getYaw(),
3979                         player->getPitch());
3980
3981         /*
3982                 Update clouds
3983         */
3984         if (clouds) {
3985                 if (sky->getCloudsVisible()) {
3986                         clouds->setVisible(true);
3987                         clouds->step(dtime);
3988                         // camera->getPosition is not enough for 3rd person views
3989                         v3f camera_node_position = camera->getCameraNode()->getPosition();
3990                         v3s16 camera_offset      = camera->getOffset();
3991                         camera_node_position.X   = camera_node_position.X + camera_offset.X * BS;
3992                         camera_node_position.Y   = camera_node_position.Y + camera_offset.Y * BS;
3993                         camera_node_position.Z   = camera_node_position.Z + camera_offset.Z * BS;
3994                         clouds->update(camera_node_position,
3995                                         sky->getCloudColor());
3996                         if (clouds->isCameraInsideCloud() && m_cache_enable_fog) {
3997                                 // if inside clouds, and fog enabled, use that as sky
3998                                 // color(s)
3999                                 video::SColor clouds_dark = clouds->getColor()
4000                                                 .getInterpolated(video::SColor(255, 0, 0, 0), 0.9);
4001                                 sky->overrideColors(clouds_dark, clouds->getColor());
4002                                 sky->setInClouds(true);
4003                                 runData.fog_range = std::fmin(runData.fog_range * 0.5f, 32.0f * BS);
4004                                 // do not draw clouds after all
4005                                 clouds->setVisible(false);
4006                         }
4007                 } else {
4008                         clouds->setVisible(false);
4009                 }
4010         }
4011
4012         /*
4013                 Update particles
4014         */
4015         client->getParticleManager()->step(dtime);
4016
4017         /*
4018                 Fog
4019         */
4020
4021         if (m_cache_enable_fog) {
4022                 driver->setFog(
4023                                 sky->getBgColor(),
4024                                 video::EFT_FOG_LINEAR,
4025                                 runData.fog_range * m_cache_fog_start,
4026                                 runData.fog_range * 1.0,
4027                                 0.01,
4028                                 false, // pixel fog
4029                                 true // range fog
4030                 );
4031         } else {
4032                 driver->setFog(
4033                                 sky->getBgColor(),
4034                                 video::EFT_FOG_LINEAR,
4035                                 100000 * BS,
4036                                 110000 * BS,
4037                                 0.01f,
4038                                 false, // pixel fog
4039                                 false // range fog
4040                 );
4041         }
4042
4043         /*
4044                 Damage camera tilt
4045         */
4046         if (player->hurt_tilt_timer > 0.0f) {
4047                 player->hurt_tilt_timer -= dtime * 6.0f;
4048
4049                 if (player->hurt_tilt_timer < 0.0f)
4050                         player->hurt_tilt_strength = 0.0f;
4051         }
4052
4053         /*
4054                 Update minimap pos and rotation
4055         */
4056         if (mapper && m_game_ui->m_flags.show_hud) {
4057                 mapper->setPos(floatToInt(player->getPosition(), BS));
4058                 mapper->setAngle(player->getYaw());
4059         }
4060
4061         /*
4062                 Get chat messages from client
4063         */
4064
4065         updateChat(dtime);
4066
4067         /*
4068                 Inventory
4069         */
4070
4071         if (player->getWieldIndex() != runData.new_playeritem)
4072                 client->setPlayerItem(runData.new_playeritem);
4073
4074         if (client->updateWieldedItem()) {
4075                 // Update wielded tool
4076                 ItemStack selected_item, hand_item;
4077                 ItemStack &tool_item = player->getWieldedItem(&selected_item, &hand_item);
4078                 camera->wield(tool_item);
4079         }
4080
4081         /*
4082                 Update block draw list every 200ms or when camera direction has
4083                 changed much
4084         */
4085         runData.update_draw_list_timer += dtime;
4086         runData.touch_blocks_timer += dtime;
4087
4088         bool draw_list_updated = false;
4089
4090         float update_draw_list_delta = 0.2f;
4091
4092         v3f camera_direction = camera->getDirection();
4093         if (runData.update_draw_list_timer >= update_draw_list_delta
4094                         || runData.update_draw_list_last_cam_dir.getDistanceFrom(camera_direction) > 0.2
4095                         || m_camera_offset_changed
4096                         || client->getEnv().getClientMap().needsUpdateDrawList()) {
4097                 runData.update_draw_list_timer = 0;
4098                 client->getEnv().getClientMap().updateDrawList();
4099                 runData.update_draw_list_last_cam_dir = camera_direction;
4100                 draw_list_updated = true;
4101         }
4102
4103         if (runData.touch_blocks_timer > update_draw_list_delta && !draw_list_updated) {
4104                 client->getEnv().getClientMap().touchMapBlocks();
4105                 runData.touch_blocks_timer = 0;
4106         }
4107
4108         if (RenderingEngine::get_shadow_renderer()) {
4109                 updateShadows();
4110         }
4111
4112         m_game_ui->update(*stats, client, draw_control, cam, runData.pointed_old, gui_chat_console, dtime);
4113
4114         /*
4115            make sure menu is on top
4116            1. Delete formspec menu reference if menu was removed
4117            2. Else, make sure formspec menu is on top
4118         */
4119         auto formspec = m_game_ui->getFormspecGUI();
4120         do { // breakable. only runs for one iteration
4121                 if (!formspec)
4122                         break;
4123
4124                 if (formspec->getReferenceCount() == 1) {
4125                         m_game_ui->deleteFormspec();
4126                         break;
4127                 }
4128
4129                 auto &loc = formspec->getFormspecLocation();
4130                 if (loc.type == InventoryLocation::NODEMETA) {
4131                         NodeMetadata *meta = client->getEnv().getClientMap().getNodeMetadata(loc.p);
4132                         if (!meta || meta->getString("formspec").empty()) {
4133                                 formspec->quitMenu();
4134                                 break;
4135                         }
4136                 }
4137
4138                 if (isMenuActive())
4139                         guiroot->bringToFront(formspec);
4140         } while (false);
4141
4142         /*
4143                 ==================== Drawing begins ====================
4144         */
4145         const video::SColor skycolor = sky->getSkyColor();
4146
4147         TimeTaker tt_draw("Draw scene", nullptr, PRECISION_MICRO);
4148         driver->beginScene(true, true, skycolor);
4149
4150         bool draw_wield_tool = (m_game_ui->m_flags.show_hud &&
4151                         (player->hud_flags & HUD_FLAG_WIELDITEM_VISIBLE) &&
4152                         (camera->getCameraMode() == CAMERA_MODE_FIRST));
4153         bool draw_crosshair = (
4154                         (player->hud_flags & HUD_FLAG_CROSSHAIR_VISIBLE) &&
4155                         (camera->getCameraMode() != CAMERA_MODE_THIRD_FRONT));
4156 #ifdef HAVE_TOUCHSCREENGUI
4157         if (isNoCrosshairAllowed())
4158                 draw_crosshair = false;
4159 #endif
4160         m_rendering_engine->draw_scene(skycolor, m_game_ui->m_flags.show_hud,
4161                         m_game_ui->m_flags.show_minimap, draw_wield_tool, draw_crosshair);
4162
4163         /*
4164                 Profiler graph
4165         */
4166         v2u32 screensize = driver->getScreenSize();
4167
4168         if (m_game_ui->m_flags.show_profiler_graph)
4169                 graph->draw(10, screensize.Y - 10, driver, g_fontengine->getFont());
4170
4171         /*
4172                 Damage flash
4173         */
4174         if (runData.damage_flash > 0.0f) {
4175                 video::SColor color(runData.damage_flash, 180, 0, 0);
4176                 driver->draw2DRectangle(color,
4177                                         core::rect<s32>(0, 0, screensize.X, screensize.Y),
4178                                         NULL);
4179
4180                 runData.damage_flash -= 384.0f * dtime;
4181         }
4182
4183         /*
4184                 ==================== End scene ====================
4185         */
4186
4187         driver->endScene();
4188
4189         stats->drawtime = tt_draw.stop(true);
4190         g_profiler->graphAdd("Draw scene [us]", stats->drawtime);
4191         g_profiler->avg("Game::updateFrame(): update frame [ms]", tt_update.stop(true));
4192 }
4193
4194 /* Log times and stuff for visualization */
4195 inline void Game::updateProfilerGraphs(ProfilerGraph *graph)
4196 {
4197         Profiler::GraphValues values;
4198         g_profiler->graphGet(values);
4199         graph->put(values);
4200 }
4201
4202 /****************************************************************************
4203  * Shadows
4204  *****************************************************************************/
4205 void Game::updateShadows()
4206 {
4207         ShadowRenderer *shadow = RenderingEngine::get_shadow_renderer();
4208         if (!shadow)
4209                 return;
4210
4211         float in_timeofday = fmod(runData.time_of_day_smooth, 1.0f);
4212
4213         float timeoftheday = getWickedTimeOfDay(in_timeofday);
4214         bool is_day = timeoftheday > 0.25 && timeoftheday < 0.75;
4215         bool is_shadow_visible = is_day ? sky->getSunVisible() : sky->getMoonVisible();
4216         shadow->setShadowIntensity(is_shadow_visible ? client->getEnv().getLocalPlayer()->getLighting().shadow_intensity : 0.0f);
4217
4218         timeoftheday = fmod(timeoftheday + 0.75f, 0.5f) + 0.25f;
4219         const float offset_constant = 10000.0f;
4220
4221         v3f light = is_day ? sky->getSunDirection() : sky->getMoonDirection();
4222
4223         v3f sun_pos = light * offset_constant;
4224
4225         if (shadow->getDirectionalLightCount() == 0)
4226                 shadow->addDirectionalLight();
4227         shadow->getDirectionalLight().setDirection(sun_pos);
4228         shadow->setTimeOfDay(in_timeofday);
4229
4230         shadow->getDirectionalLight().update_frustum(camera, client, m_camera_offset_changed);
4231 }
4232
4233 /****************************************************************************
4234  Misc
4235  ****************************************************************************/
4236
4237 void FpsControl::reset()
4238 {
4239         last_time = porting::getTimeUs();
4240 }
4241
4242 /*
4243  * On some computers framerate doesn't seem to be automatically limited
4244  */
4245 void FpsControl::limit(IrrlichtDevice *device, f32 *dtime)
4246 {
4247         const float fps_limit = (device->isWindowFocused() && !g_menumgr.pausesGame())
4248                         ? g_settings->getFloat("fps_max")
4249                         : g_settings->getFloat("fps_max_unfocused");
4250         const u64 frametime_min = 1000000.0f / std::max(fps_limit, 1.0f);
4251
4252         u64 time = porting::getTimeUs();
4253
4254         if (time > last_time) // Make sure time hasn't overflowed
4255                 busy_time = time - last_time;
4256         else
4257                 busy_time = 0;
4258
4259         if (busy_time < frametime_min) {
4260                 sleep_time = frametime_min - busy_time;
4261                 if (sleep_time > 1000)
4262                         sleep_ms(sleep_time / 1000);
4263         } else {
4264                 sleep_time = 0;
4265         }
4266
4267         // Read the timer again to accurately determine how long we actually slept,
4268         // rather than calculating it by adding sleep_time to time.
4269         time = porting::getTimeUs();
4270
4271         if (time > last_time) // Make sure last_time hasn't overflowed
4272                 *dtime = (time - last_time) / 1000000.0f;
4273         else
4274                 *dtime = 0;
4275
4276         last_time = time;
4277 }
4278
4279 void Game::showOverlayMessage(const char *msg, float dtime, int percent, bool draw_clouds)
4280 {
4281         const wchar_t *wmsg = wgettext(msg);
4282         m_rendering_engine->draw_load_screen(wmsg, guienv, texture_src, dtime, percent,
4283                 draw_clouds);
4284         delete[] wmsg;
4285 }
4286
4287 void Game::settingChangedCallback(const std::string &setting_name, void *data)
4288 {
4289         ((Game *)data)->readSettings();
4290 }
4291
4292 void Game::readSettings()
4293 {
4294         m_cache_doubletap_jump               = g_settings->getBool("doubletap_jump");
4295         m_cache_enable_clouds                = g_settings->getBool("enable_clouds");
4296         m_cache_enable_joysticks             = g_settings->getBool("enable_joysticks");
4297         m_cache_enable_particles             = g_settings->getBool("enable_particles");
4298         m_cache_enable_fog                   = g_settings->getBool("enable_fog");
4299         m_cache_mouse_sensitivity            = g_settings->getFloat("mouse_sensitivity", 0.001f, 10.0f);
4300         m_cache_joystick_frustum_sensitivity = std::max(g_settings->getFloat("joystick_frustum_sensitivity"), 0.001f);
4301         m_repeat_place_time                  = g_settings->getFloat("repeat_place_time", 0.16f, 2.0);
4302
4303         m_cache_enable_noclip                = g_settings->getBool("noclip");
4304         m_cache_enable_free_move             = g_settings->getBool("free_move");
4305
4306         m_cache_fog_start                    = g_settings->getFloat("fog_start");
4307
4308         m_cache_cam_smoothing = 0;
4309         if (g_settings->getBool("cinematic"))
4310                 m_cache_cam_smoothing = 1 - g_settings->getFloat("cinematic_camera_smoothing");
4311         else
4312                 m_cache_cam_smoothing = 1 - g_settings->getFloat("camera_smoothing");
4313
4314         m_cache_fog_start = rangelim(m_cache_fog_start, 0.0f, 0.99f);
4315         m_cache_cam_smoothing = rangelim(m_cache_cam_smoothing, 0.01f, 1.0f);
4316         m_cache_mouse_sensitivity = rangelim(m_cache_mouse_sensitivity, 0.001, 100.0);
4317
4318         m_does_lost_focus_pause_game = g_settings->getBool("pause_on_lost_focus");
4319 }
4320
4321 /****************************************************************************/
4322 /****************************************************************************
4323  Shutdown / cleanup
4324  ****************************************************************************/
4325 /****************************************************************************/
4326
4327 void Game::showDeathFormspec()
4328 {
4329         static std::string formspec_str =
4330                 std::string("formspec_version[1]") +
4331                 SIZE_TAG
4332                 "bgcolor[#320000b4;true]"
4333                 "label[4.85,1.35;" + gettext("You died") + "]"
4334                 "button_exit[4,3;3,0.5;btn_respawn;" + gettext("Respawn") + "]"
4335                 ;
4336
4337         /* Create menu */
4338         /* Note: FormspecFormSource and LocalFormspecHandler  *
4339          * are deleted by guiFormSpecMenu                     */
4340         FormspecFormSource *fs_src = new FormspecFormSource(formspec_str);
4341         LocalFormspecHandler *txt_dst = new LocalFormspecHandler("MT_DEATH_SCREEN", client);
4342
4343         auto *&formspec = m_game_ui->getFormspecGUI();
4344         GUIFormSpecMenu::create(formspec, client, m_rendering_engine->get_gui_env(),
4345                 &input->joystick, fs_src, txt_dst, client->getFormspecPrepend(), sound);
4346         formspec->setFocus("btn_respawn");
4347 }
4348
4349 #define GET_KEY_NAME(KEY) gettext(getKeySetting(#KEY).name())
4350 void Game::showPauseMenu()
4351 {
4352 #ifdef HAVE_TOUCHSCREENGUI
4353         static const std::string control_text = strgettext("Default Controls:\n"
4354                 "No menu visible:\n"
4355                 "- single tap: button activate\n"
4356                 "- double tap: place/use\n"
4357                 "- slide finger: look around\n"
4358                 "Menu/Inventory visible:\n"
4359                 "- double tap (outside):\n"
4360                 " -->close\n"
4361                 "- touch stack, touch slot:\n"
4362                 " --> move stack\n"
4363                 "- touch&drag, tap 2nd finger\n"
4364                 " --> place single item to slot\n"
4365                 );
4366 #else
4367         static const std::string control_text_template = strgettext("Controls:\n"
4368                 "- %s: move forwards\n"
4369                 "- %s: move backwards\n"
4370                 "- %s: move left\n"
4371                 "- %s: move right\n"
4372                 "- %s: jump/climb up\n"
4373                 "- %s: dig/punch\n"
4374                 "- %s: place/use\n"
4375                 "- %s: sneak/climb down\n"
4376                 "- %s: drop item\n"
4377                 "- %s: inventory\n"
4378                 "- Mouse: turn/look\n"
4379                 "- Mouse wheel: select item\n"
4380                 "- %s: chat\n"
4381         );
4382
4383         char control_text_buf[600];
4384
4385         porting::mt_snprintf(control_text_buf, sizeof(control_text_buf), control_text_template.c_str(),
4386                 GET_KEY_NAME(keymap_forward),
4387                 GET_KEY_NAME(keymap_backward),
4388                 GET_KEY_NAME(keymap_left),
4389                 GET_KEY_NAME(keymap_right),
4390                 GET_KEY_NAME(keymap_jump),
4391                 GET_KEY_NAME(keymap_dig),
4392                 GET_KEY_NAME(keymap_place),
4393                 GET_KEY_NAME(keymap_sneak),
4394                 GET_KEY_NAME(keymap_drop),
4395                 GET_KEY_NAME(keymap_inventory),
4396                 GET_KEY_NAME(keymap_chat)
4397         );
4398
4399         std::string control_text = std::string(control_text_buf);
4400         str_formspec_escape(control_text);
4401 #endif
4402
4403         float ypos = simple_singleplayer_mode ? 0.7f : 0.1f;
4404         std::ostringstream os;
4405
4406         os << "formspec_version[1]" << SIZE_TAG
4407                 << "button_exit[4," << (ypos++) << ";3,0.5;btn_continue;"
4408                 << strgettext("Continue") << "]";
4409
4410         if (!simple_singleplayer_mode) {
4411                 os << "button_exit[4," << (ypos++) << ";3,0.5;btn_change_password;"
4412                         << strgettext("Change Password") << "]";
4413         } else {
4414                 os << "field[4.95,0;5,1.5;;" << strgettext("Game paused") << ";]";
4415         }
4416
4417 #ifndef __ANDROID__
4418 #if USE_SOUND
4419         if (g_settings->getBool("enable_sound")) {
4420                 os << "button_exit[4," << (ypos++) << ";3,0.5;btn_sound;"
4421                         << strgettext("Sound Volume") << "]";
4422         }
4423 #endif
4424         os              << "button_exit[4," << (ypos++) << ";3,0.5;btn_key_config;"
4425                 << strgettext("Change Keys")  << "]";
4426 #endif
4427         os              << "button_exit[4," << (ypos++) << ";3,0.5;btn_exit_menu;"
4428                 << strgettext("Exit to Menu") << "]";
4429         os              << "button_exit[4," << (ypos++) << ";3,0.5;btn_exit_os;"
4430                 << strgettext("Exit to OS")   << "]"
4431                 << "textarea[7.5,0.25;3.9,6.25;;" << control_text << ";]"
4432                 << "textarea[0.4,0.25;3.9,6.25;;" << PROJECT_NAME_C " " VERSION_STRING "\n"
4433                 << "\n"
4434                 <<  strgettext("Game info:") << "\n";
4435         const std::string &address = client->getAddressName();
4436         static const std::string mode = strgettext("- Mode: ");
4437         if (!simple_singleplayer_mode) {
4438                 Address serverAddress = client->getServerAddress();
4439                 if (!address.empty()) {
4440                         os << mode << strgettext("Remote server") << "\n"
4441                                         << strgettext("- Address: ") << address;
4442                 } else {
4443                         os << mode << strgettext("Hosting server");
4444                 }
4445                 os << "\n" << strgettext("- Port: ") << serverAddress.getPort() << "\n";
4446         } else {
4447                 os << mode << strgettext("Singleplayer") << "\n";
4448         }
4449         if (simple_singleplayer_mode || address.empty()) {
4450                 static const std::string on = strgettext("On");
4451                 static const std::string off = strgettext("Off");
4452                 // Note: Status of enable_damage and creative_mode settings is intentionally
4453                 // NOT shown here because the game might roll its own damage system and/or do
4454                 // a per-player Creative Mode, in which case writing it here would mislead.
4455                 bool damage = g_settings->getBool("enable_damage");
4456                 const std::string &announced = g_settings->getBool("server_announce") ? on : off;
4457                 if (!simple_singleplayer_mode) {
4458                         if (damage) {
4459                                 const std::string &pvp = g_settings->getBool("enable_pvp") ? on : off;
4460                                 //~ PvP = Player versus Player
4461                                 os << strgettext("- PvP: ") << pvp << "\n";
4462                         }
4463                         os << strgettext("- Public: ") << announced << "\n";
4464                         std::string server_name = g_settings->get("server_name");
4465                         str_formspec_escape(server_name);
4466                         if (announced == on && !server_name.empty())
4467                                 os << strgettext("- Server Name: ") << server_name;
4468
4469                 }
4470         }
4471         os << ";]";
4472
4473         /* Create menu */
4474         /* Note: FormspecFormSource and LocalFormspecHandler  *
4475          * are deleted by guiFormSpecMenu                     */
4476         FormspecFormSource *fs_src = new FormspecFormSource(os.str());
4477         LocalFormspecHandler *txt_dst = new LocalFormspecHandler("MT_PAUSE_MENU");
4478
4479         auto *&formspec = m_game_ui->getFormspecGUI();
4480         GUIFormSpecMenu::create(formspec, client, m_rendering_engine->get_gui_env(),
4481                         &input->joystick, fs_src, txt_dst, client->getFormspecPrepend(), sound);
4482         formspec->setFocus("btn_continue");
4483         // game will be paused in next step, if in singleplayer (see m_is_paused)
4484         formspec->doPause = true;
4485 }
4486
4487 /****************************************************************************/
4488 /****************************************************************************
4489  extern function for launching the game
4490  ****************************************************************************/
4491 /****************************************************************************/
4492
4493 void the_game(bool *kill,
4494                 InputHandler *input,
4495                 RenderingEngine *rendering_engine,
4496                 const GameStartData &start_data,
4497                 std::string &error_message,
4498                 ChatBackend &chat_backend,
4499                 bool *reconnect_requested) // Used for local game
4500 {
4501         Game game;
4502
4503         /* Make a copy of the server address because if a local singleplayer server
4504          * is created then this is updated and we don't want to change the value
4505          * passed to us by the calling function
4506          */
4507
4508         try {
4509
4510                 if (game.startup(kill, input, rendering_engine, start_data,
4511                                 error_message, reconnect_requested, &chat_backend)) {
4512                         game.run();
4513                 }
4514
4515         } catch (SerializationError &e) {
4516                 const std::string ver_err = fmtgettext("The server is probably running a different version of %s.", PROJECT_NAME_C);
4517                 error_message = strgettext("A serialization error occurred:") +"\n"
4518                                 + e.what() + "\n\n" + ver_err;
4519                 errorstream << error_message << std::endl;
4520         } catch (ServerError &e) {
4521                 error_message = e.what();
4522                 errorstream << "ServerError: " << error_message << std::endl;
4523         } catch (ModError &e) {
4524                 // DO NOT TRANSLATE the `ModError`, it's used by ui.lua
4525                 error_message = std::string("ModError: ") + e.what() +
4526                                 strgettext("\nCheck debug.txt for details.");
4527                 errorstream << error_message << std::endl;
4528         }
4529         game.shutdown();
4530 }