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