+
+#ifdef HAVE_TOUCHSCREENGUI
+
+ if (g_touchscreengui)
+ g_touchscreengui->init(tsrc, porting::getDisplayDensity());
+
+#endif
+
+ return true;
+}
+
+bool Game::connectToServer(const std::string &playername,
+ const std::string &password, std::string *address, u16 port,
+ bool *connect_ok, bool *aborted)
+{
+ showOverlayMessage("Resolving address...", 0, 75);
+
+ Address connect_address(0, 0, 0, 0, port);
+
+ try {
+ connect_address.Resolve(address->c_str());
+
+ if (connect_address.isZero()) { // i.e. INADDR_ANY, IN6ADDR_ANY
+ //connect_address.Resolve("localhost");
+ if (connect_address.isIPv6()) {
+ IPv6AddressBytes addr_bytes;
+ addr_bytes.bytes[15] = 1;
+ connect_address.setAddress(&addr_bytes);
+ } else {
+ connect_address.setAddress(127, 0, 0, 1);
+ }
+ }
+ } catch (ResolveError &e) {
+ *error_message = L"Couldn't resolve address: " + narrow_to_wide(e.what());
+ errorstream << wide_to_narrow(*error_message) << std::endl;
+ return false;
+ }
+
+ if (connect_address.isIPv6() && !g_settings->getBool("enable_ipv6")) {
+ *error_message = L"Unable to connect to " +
+ narrow_to_wide(connect_address.serializeString()) +
+ L" because IPv6 is disabled";
+ errorstream << wide_to_narrow(*error_message) << std::endl;
+ return false;
+ }
+
+ client = new Client(device, playername.c_str(), password, *draw_control,
+ texture_src, shader_src, itemdef_manager, nodedef_manager, sound,
+ eventmgr, connect_address.isIPv6());
+
+ if (!client)
+ return false;
+
+ gamedef = client; // Client acts as our GameDef
+
+
+ infostream << "Connecting to server at ";
+ connect_address.print(&infostream);
+ infostream << std::endl;
+
+ client->connect(connect_address);
+
+
+ /*
+ Wait for server to accept connection
+ */
+
+ try {
+ input->clear();
+
+ FpsControl fps_control = { 0 };
+ f32 dtime; // in seconds
+
+ while (device->run()) {
+
+ limitFps(&fps_control, &dtime);
+
+ // Update client and server
+ client->step(dtime);
+
+ if (server != NULL)
+ server->step(dtime);
+
+ // End condition
+ if (client->getState() == LC_Init) {
+ *connect_ok = true;
+ break;
+ }
+
+ // Break conditions
+ if (client->accessDenied()) {
+ *error_message = L"Access denied. Reason: "
+ + client->accessDeniedReason();
+ errorstream << wide_to_narrow(*error_message) << std::endl;
+ break;
+ }
+
+ if (input->wasKeyDown(EscapeKey) || input->wasKeyDown(CancelKey)) {
+ *aborted = true;
+ infostream << "Connect aborted [Escape]" << std::endl;
+ break;
+ }
+
+ // Update status
+ showOverlayMessage("Connecting to server...", dtime, 100);
+ }
+ } catch (con::PeerNotFoundException &e) {
+ // TODO: Should something be done here? At least an info/error
+ // message?
+ return false;
+ }
+
+ return true;
+}
+
+bool Game::getServerContent(bool *aborted)
+{
+ input->clear();
+
+ FpsControl fps_control = { 0 };
+ f32 dtime; // in seconds
+
+ while (device->run()) {
+
+ limitFps(&fps_control, &dtime);
+
+ // Update client and server
+ client->step(dtime);
+
+ if (server != NULL)
+ server->step(dtime);
+
+ // End condition
+ if (client->mediaReceived() && client->itemdefReceived() &&
+ client->nodedefReceived()) {
+ break;
+ }
+
+ // Error conditions
+ if (client->accessDenied()) {
+ *error_message = L"Access denied. Reason: "
+ + client->accessDeniedReason();
+ errorstream << wide_to_narrow(*error_message) << std::endl;
+ return false;
+ }
+
+ if (client->getState() < LC_Init) {
+ *error_message = L"Client disconnected";
+ errorstream << wide_to_narrow(*error_message) << std::endl;
+ return false;
+ }
+
+ if (input->wasKeyDown(EscapeKey) || input->wasKeyDown(CancelKey)) {
+ *aborted = true;
+ infostream << "Connect aborted [Escape]" << std::endl;
+ return false;
+ }
+
+ // Display status
+ int progress = 0;
+
+ if (!client->itemdefReceived()) {
+ wchar_t *text = wgettext("Item definitions...");
+ progress = 0;
+ draw_load_screen(text, device, guienv, font, dtime, progress);
+ delete[] text;
+ } else if (!client->nodedefReceived()) {
+ wchar_t *text = wgettext("Node definitions...");
+ progress = 25;
+ draw_load_screen(text, device, guienv, font, dtime, progress);
+ delete[] text;
+ } else {
+ std::stringstream message;
+ message.precision(3);
+ message << gettext("Media...");
+
+ if ((USE_CURL == 0) ||
+ (!g_settings->getBool("enable_remote_media_server"))) {
+ float cur = client->getCurRate();
+ std::string cur_unit = gettext(" KB/s");
+
+ if (cur > 900) {
+ cur /= 1024.0;
+ cur_unit = gettext(" MB/s");
+ }
+
+ message << " ( " << cur << cur_unit << " )";
+ }
+
+ progress = 50 + client->mediaReceiveProgress() * 50 + 0.5;
+ draw_load_screen(narrow_to_wide(message.str().c_str()), device,
+ guienv, font, dtime, progress);
+ }
+ }
+
+ return true;
+}
+
+
+
+/****************************************************************************
+ Run
+ ****************************************************************************/
+
+inline void Game::updateInteractTimers(GameRunData *args, f32 dtime)
+{
+ if (args->nodig_delay_timer >= 0)
+ args->nodig_delay_timer -= dtime;
+
+ if (args->object_hit_delay_timer >= 0)
+ args->object_hit_delay_timer -= dtime;
+
+ args->time_from_last_punch += dtime;
+}
+
+
+/* returns false if game should exit, otherwise true
+ */
+inline bool Game::checkConnection()
+{
+ if (client->accessDenied()) {
+ *error_message = L"Access denied. Reason: "
+ + client->accessDeniedReason();
+ errorstream << wide_to_narrow(*error_message) << std::endl;
+ return false;
+ }
+
+ return true;
+}
+
+
+/* returns false if game should exit, otherwise true
+ */
+inline bool Game::handleCallbacks()
+{
+ if (g_gamecallback->disconnect_requested) {
+ g_gamecallback->disconnect_requested = false;
+ return false;
+ }
+
+ if (g_gamecallback->changepassword_requested) {
+ (new GUIPasswordChange(guienv, guiroot, -1,
+ &g_menumgr, client))->drop();
+ g_gamecallback->changepassword_requested = false;
+ }
+
+ if (g_gamecallback->changevolume_requested) {
+ (new GUIVolumeChange(guienv, guiroot, -1,
+ &g_menumgr, client))->drop();
+ g_gamecallback->changevolume_requested = false;
+ }
+
+ if (g_gamecallback->keyconfig_requested) {
+ (new GUIKeyChangeMenu(guienv, guiroot, -1,
+ &g_menumgr))->drop();
+ g_gamecallback->keyconfig_requested = false;
+ }
+
+ if (g_gamecallback->keyconfig_changed) {
+ keycache.populate(); // update the cache with new settings
+ g_gamecallback->keyconfig_changed = false;
+ }
+
+ return true;
+}
+
+
+void Game::processQueues()
+{
+ texture_src->processQueue();
+ itemdef_manager->processQueue(gamedef);
+ shader_src->processQueue();
+}
+
+
+void Game::addProfilerGraphs(const RunStats &stats,
+ const FpsControl &draw_times, f32 dtime)
+{
+ g_profiler->graphAdd("mainloop_other",
+ draw_times.busy_time / 1000.0f - stats.drawtime / 1000.0f);
+
+ if (draw_times.sleep_time != 0)
+ g_profiler->graphAdd("mainloop_sleep", draw_times.sleep_time / 1000.0f);
+ g_profiler->graphAdd("mainloop_dtime", dtime);
+
+ g_profiler->add("Elapsed time", dtime);
+ g_profiler->avg("FPS", 1. / dtime);
+}
+
+
+void Game::updateStats(RunStats *stats, const FpsControl &draw_times,
+ f32 dtime)
+{
+
+ f32 jitter;
+ Jitter *jp;
+
+ /* Time average and jitter calculation
+ */
+ jp = &stats->dtime_jitter;
+ jp->avg = jp->avg * 0.96 + dtime * 0.04;
+
+ jitter = dtime - jp->avg;
+
+ if (jitter > jp->max)
+ jp->max = jitter;
+
+ jp->counter += dtime;
+
+ if (jp->counter > 0.0) {
+ jp->counter -= 3.0;
+ jp->max_sample = jp->max;
+ jp->max_fraction = jp->max_sample / (jp->avg + 0.001);
+ jp->max = 0.0;
+ }
+
+ /* Busytime average and jitter calculation
+ */
+ jp = &stats->busy_time_jitter;
+ jp->avg = jp->avg + draw_times.busy_time * 0.02;
+
+ jitter = draw_times.busy_time - jp->avg;
+
+ if (jitter > jp->max)
+ jp->max = jitter;
+ if (jitter < jp->min)
+ jp->min = jitter;
+
+ jp->counter += dtime;
+
+ if (jp->counter > 0.0) {
+ jp->counter -= 3.0;
+ jp->max_sample = jp->max;
+ jp->min_sample = jp->min;
+ jp->max = 0.0;
+ jp->min = 0.0;
+ }
+}
+
+
+
+/****************************************************************************
+ Input handling
+ ****************************************************************************/
+
+void Game::processUserInput(VolatileRunFlags *flags,
+ GameRunData *interact_args, f32 dtime)
+{
+ // Reset input if window not active or some menu is active
+ if (device->isWindowActive() == false
+ || noMenuActive() == false
+ || guienv->hasFocus(gui_chat_console)) {
+ input->clear();
+ }
+
+ if (!guienv->hasFocus(gui_chat_console) && gui_chat_console->isOpen()) {
+ gui_chat_console->closeConsoleAtOnce();
+ }
+
+ // Input handler step() (used by the random input generator)
+ input->step(dtime);
+
+#ifdef HAVE_TOUCHSCREENGUI
+
+ if (g_touchscreengui) {
+ g_touchscreengui->step(dtime);
+ }
+
+#endif
+#ifdef __ANDROID__
+
+ if (current_formspec != 0)
+ current_formspec->getAndroidUIInput();
+
+#endif
+
+ // Increase timer for double tap of "keymap_jump"
+ if (g_settings->getBool("doubletap_jump") && interact_args->jump_timer <= 0.2)
+ interact_args->jump_timer += dtime;
+
+ processKeyboardInput(
+ flags,
+ &interact_args->statustext_time,
+ &interact_args->jump_timer,
+ &interact_args->reset_jump_timer,
+ &interact_args->profiler_current_page,
+ interact_args->profiler_max_page);
+
+ processItemSelection(&interact_args->new_playeritem);
+}
+
+
+void Game::processKeyboardInput(VolatileRunFlags *flags,
+ float *statustext_time,
+ float *jump_timer,
+ bool *reset_jump_timer,
+ u32 *profiler_current_page,
+ u32 profiler_max_page)
+{
+
+ //TimeTaker tt("process kybd input", NULL, PRECISION_NANO);
+
+ if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_DROP])) {
+ dropSelectedItem();
+ } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_INVENTORY])) {
+ openInventory();
+ } else if (input->wasKeyDown(EscapeKey) || input->wasKeyDown(CancelKey)) {
+ show_pause_menu(¤t_formspec, client, gamedef, texture_src, device,
+ simple_singleplayer_mode);
+ } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_CHAT])) {
+ show_chat_menu(¤t_formspec, client, gamedef, texture_src, device,
+ client, "");
+ } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_CMD])) {
+ show_chat_menu(¤t_formspec, client, gamedef, texture_src, device,
+ client, "/");
+ } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_CONSOLE])) {
+ openConsole();
+ } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_FREEMOVE])) {
+ toggleFreeMove(statustext_time);
+ } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_JUMP])) {
+ toggleFreeMoveAlt(statustext_time, jump_timer);
+ *reset_jump_timer = true;
+ } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_FASTMOVE])) {
+ toggleFast(statustext_time);
+ } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_NOCLIP])) {
+ toggleNoClip(statustext_time);
+ } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_SCREENSHOT])) {
+ client->makeScreenshot(device);
+ } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_TOGGLE_HUD])) {
+ toggleHud(statustext_time, &flags->show_hud);
+ } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_TOGGLE_CHAT])) {
+ toggleChat(statustext_time, &flags->show_chat);
+ } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_TOGGLE_FORCE_FOG_OFF])) {
+ toggleFog(statustext_time, &flags->force_fog_off);
+ } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_TOGGLE_UPDATE_CAMERA])) {
+ toggleUpdateCamera(statustext_time, &flags->disable_camera_update);
+ } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_TOGGLE_DEBUG])) {
+ toggleDebug(statustext_time, &flags->show_debug, &flags->show_profiler_graph);
+ } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_TOGGLE_PROFILER])) {
+ toggleProfiler(statustext_time, profiler_current_page, profiler_max_page);
+ } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_INCREASE_VIEWING_RANGE])) {
+ increaseViewRange(statustext_time);
+ } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_DECREASE_VIEWING_RANGE])) {
+ decreaseViewRange(statustext_time);
+ } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_RANGESELECT])) {
+ toggleFullViewRange(statustext_time);
+ } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_QUICKTUNE_NEXT]))
+ quicktune->next();
+ else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_QUICKTUNE_PREV]))
+ quicktune->prev();
+ else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_QUICKTUNE_INC]))
+ quicktune->inc();
+ else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_QUICKTUNE_DEC]))
+ quicktune->dec();
+ else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_DEBUG_STACKS])) {
+ // Print debug stacks
+ dstream << "-----------------------------------------"
+ << std::endl;
+ dstream << DTIME << "Printing debug stacks:" << std::endl;
+ dstream << "-----------------------------------------"
+ << std::endl;
+ debug_stacks_print();
+ }
+
+ if (!input->isKeyDown(getKeySetting("keymap_jump")) && *reset_jump_timer) {
+ *reset_jump_timer = false;
+ *jump_timer = 0.0;
+ }
+
+ //tt.stop();
+
+ if (quicktune->hasMessage()) {
+ std::string msg = quicktune->getMessage();
+ statustext = narrow_to_wide(msg);
+ *statustext_time = 0;
+ }
+}
+
+
+void Game::processItemSelection(u16 *new_playeritem)
+{
+ LocalPlayer *player = client->getEnv().getLocalPlayer();
+
+ /* Item selection using mouse wheel
+ */
+ *new_playeritem = client->getPlayerItem();
+
+ s32 wheel = input->getMouseWheel();
+ u16 max_item = MYMIN(PLAYER_INVENTORY_SIZE - 1,
+ player->hud_hotbar_itemcount - 1);
+
+ if (wheel < 0)
+ *new_playeritem = *new_playeritem < max_item ? *new_playeritem + 1 : 0;
+ else if (wheel > 0)
+ *new_playeritem = *new_playeritem > 0 ? *new_playeritem - 1 : max_item;
+ // else wheel == 0
+
+
+ /* Item selection using keyboard
+ */
+ for (u16 i = 0; i < 10; i++) {
+ static const KeyPress *item_keys[10] = {
+ NumberKey + 1, NumberKey + 2, NumberKey + 3, NumberKey + 4,
+ NumberKey + 5, NumberKey + 6, NumberKey + 7, NumberKey + 8,
+ NumberKey + 9, NumberKey + 0,
+ };
+
+ if (input->wasKeyDown(*item_keys[i])) {
+ if (i < PLAYER_INVENTORY_SIZE && i < player->hud_hotbar_itemcount) {
+ *new_playeritem = i;
+ infostream << "Selected item: " << new_playeritem << std::endl;
+ }
+ break;
+ }
+ }
+}
+
+
+void Game::dropSelectedItem()
+{
+ IDropAction *a = new IDropAction();
+ a->count = 0;
+ a->from_inv.setCurrentPlayer();
+ a->from_list = "main";
+ a->from_i = client->getPlayerItem();
+ client->inventoryAction(a);
+}
+
+
+void Game::openInventory()
+{
+ infostream << "the_game: " << "Launching inventory" << std::endl;
+
+ PlayerInventoryFormSource *fs_src = new PlayerInventoryFormSource(client);
+ TextDest *txt_dst = new TextDestPlayerInventory(client);
+
+ create_formspec_menu(¤t_formspec, client, gamedef, texture_src,
+ device, fs_src, txt_dst, client);
+
+ InventoryLocation inventoryloc;
+ inventoryloc.setCurrentPlayer();
+ current_formspec->setFormSpec(fs_src->getForm(), inventoryloc);
+}
+
+
+void Game::openConsole()
+{
+ if (!gui_chat_console->isOpenInhibited()) {
+ // Open up to over half of the screen
+ gui_chat_console->openConsole(0.6);
+ guienv->setFocus(gui_chat_console);
+ }
+}
+
+
+void Game::toggleFreeMove(float *statustext_time)
+{
+ static const wchar_t *msg[] = { L"free_move disabled", L"free_move enabled" };
+
+ bool free_move = !g_settings->getBool("free_move");
+ g_settings->set("free_move", bool_to_cstr(free_move));
+
+ *statustext_time = 0;
+ statustext = msg[free_move];
+ if (free_move && !client->checkPrivilege("fly"))
+ statustext += L" (note: no 'fly' privilege)";
+}
+
+
+void Game::toggleFreeMoveAlt(float *statustext_time, float *jump_timer)
+{
+ if (g_settings->getBool("doubletap_jump") && *jump_timer < 0.2f)
+ toggleFreeMove(statustext_time);
+}
+
+
+void Game::toggleFast(float *statustext_time)
+{
+ static const wchar_t *msg[] = { L"fast_move disabled", L"fast_move enabled" };
+ bool fast_move = !g_settings->getBool("fast_move");
+ g_settings->set("fast_move", bool_to_cstr(fast_move));
+
+ *statustext_time = 0;
+ statustext = msg[fast_move];
+
+ if (fast_move && !client->checkPrivilege("fast"))
+ statustext += L" (note: no 'fast' privilege)";
+}
+
+
+void Game::toggleNoClip(float *statustext_time)
+{
+ static const wchar_t *msg[] = { L"noclip disabled", L"noclip enabled" };
+ bool noclip = !g_settings->getBool("noclip");
+ g_settings->set("noclip", bool_to_cstr(noclip));
+
+ *statustext_time = 0;
+ statustext = msg[noclip];
+
+ if (noclip && !client->checkPrivilege("noclip"))
+ statustext += L" (note: no 'noclip' privilege)";
+}
+
+
+void Game::toggleChat(float *statustext_time, bool *flag)
+{
+ static const wchar_t *msg[] = { L"Chat hidden", L"Chat shown" };
+
+ *flag = !*flag;
+ *statustext_time = 0;
+ statustext = msg[*flag];
+}
+
+
+void Game::toggleHud(float *statustext_time, bool *flag)
+{
+ static const wchar_t *msg[] = { L"HUD hidden", L"HUD shown" };
+
+ *flag = !*flag;
+ *statustext_time = 0;
+ statustext = msg[*flag];
+ client->setHighlighted(client->getHighlighted(), *flag);
+}
+
+
+void Game::toggleFog(float *statustext_time, bool *flag)
+{
+ static const wchar_t *msg[] = { L"Fog enabled", L"Fog disabled" };
+
+ *flag = !*flag;
+ *statustext_time = 0;
+ statustext = msg[*flag];
+}
+
+
+void Game::toggleDebug(float *statustext_time, bool *show_debug,
+ bool *show_profiler_graph)
+{
+ // Initial / 3x toggle: Chat only
+ // 1x toggle: Debug text with chat
+ // 2x toggle: Debug text with profiler graph
+ if (!*show_debug) {
+ *show_debug = true;
+ *show_profiler_graph = false;
+ statustext = L"Debug info shown";
+ } else if (*show_profiler_graph) {
+ *show_debug = false;
+ *show_profiler_graph = false;
+ statustext = L"Debug info and profiler graph hidden";
+ } else {
+ *show_profiler_graph = true;
+ statustext = L"Profiler graph shown";
+ }
+ *statustext_time = 0;
+}
+
+
+void Game::toggleUpdateCamera(float *statustext_time, bool *flag)
+{
+ static const wchar_t *msg[] = {
+ L"Camera update enabled",
+ L"Camera update disabled"
+ };
+
+ *flag = !*flag;
+ *statustext_time = 0;
+ statustext = msg[*flag];
+}
+
+
+void Game::toggleProfiler(float *statustext_time, u32 *profiler_current_page,
+ u32 profiler_max_page)
+{
+ *profiler_current_page = (*profiler_current_page + 1) % (profiler_max_page + 1);
+
+ // FIXME: This updates the profiler with incomplete values
+ update_profiler_gui(guitext_profiler, font, text_height,
+ *profiler_current_page, profiler_max_page);
+
+ if (*profiler_current_page != 0) {
+ std::wstringstream sstr;
+ sstr << "Profiler shown (page " << *profiler_current_page
+ << " of " << profiler_max_page << ")";
+ statustext = sstr.str();
+ } else {
+ statustext = L"Profiler hidden";
+ }
+ *statustext_time = 0;
+}
+
+
+void Game::increaseViewRange(float *statustext_time)
+{
+ s16 range = g_settings->getS16("viewing_range_nodes_min");
+ s16 range_new = range + 10;
+ g_settings->set("viewing_range_nodes_min", itos(range_new));
+ statustext = narrow_to_wide("Minimum viewing range changed to "
+ + itos(range_new));
+ *statustext_time = 0;
+}
+
+
+void Game::decreaseViewRange(float *statustext_time)
+{
+ s16 range = g_settings->getS16("viewing_range_nodes_min");
+ s16 range_new = range - 10;
+
+ if (range_new < 0)
+ range_new = range;
+
+ g_settings->set("viewing_range_nodes_min", itos(range_new));
+ statustext = narrow_to_wide("Minimum viewing range changed to "
+ + itos(range_new));
+ *statustext_time = 0;
+}
+
+
+void Game::toggleFullViewRange(float *statustext_time)
+{
+ static const wchar_t *msg[] = {
+ L"Disabled full viewing range",
+ L"Enabled full viewing range"
+ };
+
+ draw_control->range_all = !draw_control->range_all;
+ infostream << msg[draw_control->range_all] << std::endl;
+ statustext = msg[draw_control->range_all];
+ *statustext_time = 0;
+}
+
+
+void Game::updateCameraDirection(CameraOrientation *cam,
+ VolatileRunFlags *flags)
+{
+ // float turn_amount = 0; // Deprecated?
+
+ if (!(device->isWindowActive() && noMenuActive()) || random_input) {
+
+ // FIXME: Clean this up
+
+#ifndef ANDROID
+ // Mac OSX gets upset if this is set every frame
+ if (device->getCursorControl()->isVisible() == false)
+ device->getCursorControl()->setVisible(true);
+#endif
+
+ //infostream<<"window inactive"<<std::endl;
+ flags->first_loop_after_window_activation = true;
+ return;
+ }
+
+#ifndef __ANDROID__
+ if (!random_input) {
+ // Mac OSX gets upset if this is set every frame
+ if (device->getCursorControl()->isVisible())
+ device->getCursorControl()->setVisible(false);
+ }
+#endif
+
+ if (flags->first_loop_after_window_activation) {
+ //infostream<<"window active, first loop"<<std::endl;
+ flags->first_loop_after_window_activation = false;
+ } else {
+
+#ifdef HAVE_TOUCHSCREENGUI
+
+ if (g_touchscreengui) {
+ camera_yaw = g_touchscreengui->getYaw();
+ camera_pitch = g_touchscreengui->getPitch();
+ } else {
+#endif
+ s32 dx = input->getMousePos().X - (driver->getScreenSize().Width / 2);
+ s32 dy = input->getMousePos().Y - (driver->getScreenSize().Height / 2);
+
+ if (flags->invert_mouse
+ || (camera->getCameraMode() == CAMERA_MODE_THIRD_FRONT)) {
+ dy = -dy;
+ }
+
+ //infostream<<"window active, pos difference "<<dx<<","<<dy<<std::endl;
+
+ float d = g_settings->getFloat("mouse_sensitivity");
+ d = rangelim(d, 0.01, 100.0);
+ cam->camera_yaw -= dx * d;
+ cam->camera_pitch += dy * d;
+ // turn_amount = v2f(dx, dy).getLength() * d; // deprecated?
+
+#ifdef HAVE_TOUCHSCREENGUI
+ }
+#endif
+
+ if (cam->camera_pitch < -89.5)
+ cam->camera_pitch = -89.5;
+ else if (cam->camera_pitch > 89.5)
+ cam->camera_pitch = 89.5;
+ }
+
+ input->setMousePos(driver->getScreenSize().Width / 2,
+ driver->getScreenSize().Height / 2);
+
+ // Deprecated? Not used anywhere else
+ // recent_turn_speed = recent_turn_speed * 0.9 + turn_amount * 0.1;
+ // std::cerr<<"recent_turn_speed = "<<recent_turn_speed<<std::endl;
+}
+
+
+void Game::updatePlayerControl(const CameraOrientation &cam)
+{
+ //TimeTaker tt("update player control", NULL, PRECISION_NANO);
+
+ PlayerControl control(
+ input->isKeyDown(keycache.key[KeyCache::KEYMAP_ID_FORWARD]),
+ input->isKeyDown(keycache.key[KeyCache::KEYMAP_ID_BACKWARD]),
+ input->isKeyDown(keycache.key[KeyCache::KEYMAP_ID_LEFT]),
+ input->isKeyDown(keycache.key[KeyCache::KEYMAP_ID_RIGHT]),
+ input->isKeyDown(keycache.key[KeyCache::KEYMAP_ID_JUMP]),
+ input->isKeyDown(keycache.key[KeyCache::KEYMAP_ID_SPECIAL1]),
+ input->isKeyDown(keycache.key[KeyCache::KEYMAP_ID_SNEAK]),
+ input->getLeftState(),
+ input->getRightState(),
+ cam.camera_pitch,
+ cam.camera_yaw
+ );
+ client->setPlayerControl(control);
+ LocalPlayer *player = client->getEnv().getLocalPlayer();
+ player->keyPressed =
+ ( (u32)(input->isKeyDown(keycache.key[KeyCache::KEYMAP_ID_FORWARD]) & 0x1) << 0) |
+ ( (u32)(input->isKeyDown(keycache.key[KeyCache::KEYMAP_ID_BACKWARD]) & 0x1) << 1) |
+ ( (u32)(input->isKeyDown(keycache.key[KeyCache::KEYMAP_ID_LEFT]) & 0x1) << 2) |
+ ( (u32)(input->isKeyDown(keycache.key[KeyCache::KEYMAP_ID_RIGHT]) & 0x1) << 3) |
+ ( (u32)(input->isKeyDown(keycache.key[KeyCache::KEYMAP_ID_JUMP]) & 0x1) << 4) |
+ ( (u32)(input->isKeyDown(keycache.key[KeyCache::KEYMAP_ID_SPECIAL1]) & 0x1) << 5) |
+ ( (u32)(input->isKeyDown(keycache.key[KeyCache::KEYMAP_ID_SNEAK]) & 0x1) << 6) |
+ ( (u32)(input->getLeftState() & 0x1) << 7) |
+ ( (u32)(input->getRightState() & 0x1) << 8
+ );
+
+ //tt.stop();
+}
+
+
+inline void Game::step(f32 *dtime)
+{
+ bool can_be_and_is_paused =
+ (simple_singleplayer_mode && g_menumgr.pausesGame());
+
+ if (can_be_and_is_paused) { // This is for a singleplayer server
+ *dtime = 0; // No time passes
+ } else {
+ if (server != NULL) {
+ //TimeTaker timer("server->step(dtime)");
+ server->step(*dtime);
+ }
+
+ //TimeTaker timer("client.step(dtime)");
+ client->step(*dtime);
+ }
+}
+
+
+void Game::processClientEvents(CameraOrientation *cam, float *damage_flash)
+{
+ ClientEvent event = client->getClientEvent();
+
+ LocalPlayer *player = client->getEnv().getLocalPlayer();
+
+ for ( ; event.type != CE_NONE; event = client->getClientEvent()) {
+
+ if (event.type == CE_PLAYER_DAMAGE &&
+ client->getHP() != 0) {
+ //u16 damage = event.player_damage.amount;
+ //infostream<<"Player damage: "<<damage<<std::endl;
+
+ *damage_flash += 100.0;
+ *damage_flash += 8.0 * event.player_damage.amount;
+
+ player->hurt_tilt_timer = 1.5;
+ player->hurt_tilt_strength = event.player_damage.amount / 4;
+ player->hurt_tilt_strength = rangelim(player->hurt_tilt_strength, 1.0, 4.0);
+
+ MtEvent *e = new SimpleTriggerEvent("PlayerDamage");
+ gamedef->event()->put(e);
+ } else if (event.type == CE_PLAYER_FORCE_MOVE) {
+ cam->camera_yaw = event.player_force_move.yaw;
+ cam->camera_pitch = event.player_force_move.pitch;
+ } else if (event.type == CE_DEATHSCREEN) {
+ show_deathscreen(¤t_formspec, client, gamedef, texture_src,
+ device, client);
+
+ chat_backend->addMessage(L"", L"You died.");
+
+ /* Handle visualization */
+ *damage_flash = 0;
+ player->hurt_tilt_timer = 0;
+ player->hurt_tilt_strength = 0;
+
+ } else if (event.type == CE_SHOW_FORMSPEC) {
+ FormspecFormSource *fs_src =
+ new FormspecFormSource(*(event.show_formspec.formspec));
+ TextDestPlayerInventory *txt_dst =
+ new TextDestPlayerInventory(client, *(event.show_formspec.formname));
+
+ create_formspec_menu(¤t_formspec, client, gamedef,
+ texture_src, device, fs_src, txt_dst, client);
+
+ delete(event.show_formspec.formspec);
+ delete(event.show_formspec.formname);
+ } else if (event.type == CE_SPAWN_PARTICLE) {
+ video::ITexture *texture =
+ gamedef->tsrc()->getTexture(*(event.spawn_particle.texture));
+
+ new Particle(gamedef, smgr, player, client->getEnv(),
+ *event.spawn_particle.pos,
+ *event.spawn_particle.vel,
+ *event.spawn_particle.acc,
+ event.spawn_particle.expirationtime,
+ event.spawn_particle.size,
+ event.spawn_particle.collisiondetection,
+ event.spawn_particle.vertical,
+ texture,
+ v2f(0.0, 0.0),
+ v2f(1.0, 1.0));
+ } else if (event.type == CE_ADD_PARTICLESPAWNER) {
+ video::ITexture *texture =
+ gamedef->tsrc()->getTexture(*(event.add_particlespawner.texture));
+
+ new ParticleSpawner(gamedef, smgr, player,
+ event.add_particlespawner.amount,
+ event.add_particlespawner.spawntime,
+ *event.add_particlespawner.minpos,
+ *event.add_particlespawner.maxpos,
+ *event.add_particlespawner.minvel,
+ *event.add_particlespawner.maxvel,
+ *event.add_particlespawner.minacc,
+ *event.add_particlespawner.maxacc,
+ event.add_particlespawner.minexptime,
+ event.add_particlespawner.maxexptime,
+ event.add_particlespawner.minsize,
+ event.add_particlespawner.maxsize,
+ event.add_particlespawner.collisiondetection,
+ event.add_particlespawner.vertical,
+ texture,
+ event.add_particlespawner.id);
+ } else if (event.type == CE_DELETE_PARTICLESPAWNER) {
+ delete_particlespawner(event.delete_particlespawner.id);
+ } else if (event.type == CE_HUDADD) {
+ u32 id = event.hudadd.id;
+
+ LocalPlayer *player = client->getEnv().getLocalPlayer();
+ HudElement *e = player->getHud(id);
+
+ if (e != NULL) {
+ delete event.hudadd.pos;
+ delete event.hudadd.name;
+ delete event.hudadd.scale;
+ delete event.hudadd.text;
+ delete event.hudadd.align;
+ delete event.hudadd.offset;
+ delete event.hudadd.world_pos;
+ delete event.hudadd.size;
+ continue;
+ }
+
+ e = new HudElement;
+ e->type = (HudElementType)event.hudadd.type;
+ e->pos = *event.hudadd.pos;
+ e->name = *event.hudadd.name;
+ e->scale = *event.hudadd.scale;
+ e->text = *event.hudadd.text;
+ e->number = event.hudadd.number;
+ e->item = event.hudadd.item;
+ e->dir = event.hudadd.dir;
+ e->align = *event.hudadd.align;
+ e->offset = *event.hudadd.offset;
+ e->world_pos = *event.hudadd.world_pos;
+ e->size = *event.hudadd.size;
+
+ u32 new_id = player->addHud(e);
+ //if this isn't true our huds aren't consistent
+ assert(new_id == id);
+
+ delete event.hudadd.pos;
+ delete event.hudadd.name;
+ delete event.hudadd.scale;
+ delete event.hudadd.text;
+ delete event.hudadd.align;
+ delete event.hudadd.offset;
+ delete event.hudadd.world_pos;
+ delete event.hudadd.size;
+ } else if (event.type == CE_HUDRM) {
+ HudElement *e = player->removeHud(event.hudrm.id);
+
+ if (e != NULL)
+ delete(e);
+ } else if (event.type == CE_HUDCHANGE) {
+ u32 id = event.hudchange.id;
+ HudElement *e = player->getHud(id);
+
+ if (e == NULL) {
+ delete event.hudchange.v3fdata;
+ delete event.hudchange.v2fdata;
+ delete event.hudchange.sdata;
+ delete event.hudchange.v2s32data;
+ continue;
+ }
+
+ switch (event.hudchange.stat) {
+ case HUD_STAT_POS:
+ e->pos = *event.hudchange.v2fdata;
+ break;
+
+ case HUD_STAT_NAME:
+ e->name = *event.hudchange.sdata;
+ break;
+
+ case HUD_STAT_SCALE:
+ e->scale = *event.hudchange.v2fdata;
+ break;
+
+ case HUD_STAT_TEXT:
+ e->text = *event.hudchange.sdata;
+ break;
+
+ case HUD_STAT_NUMBER:
+ e->number = event.hudchange.data;
+ break;
+
+ case HUD_STAT_ITEM:
+ e->item = event.hudchange.data;
+ break;
+
+ case HUD_STAT_DIR:
+ e->dir = event.hudchange.data;
+ break;
+
+ case HUD_STAT_ALIGN:
+ e->align = *event.hudchange.v2fdata;
+ break;
+
+ case HUD_STAT_OFFSET:
+ e->offset = *event.hudchange.v2fdata;
+ break;
+
+ case HUD_STAT_WORLD_POS:
+ e->world_pos = *event.hudchange.v3fdata;
+ break;
+
+ case HUD_STAT_SIZE:
+ e->size = *event.hudchange.v2s32data;
+ break;
+ }
+
+ delete event.hudchange.v3fdata;
+ delete event.hudchange.v2fdata;
+ delete event.hudchange.sdata;
+ delete event.hudchange.v2s32data;
+ } else if (event.type == CE_SET_SKY) {
+ sky->setVisible(false);
+
+ if (skybox) {
+ skybox->remove();
+ skybox = NULL;
+ }
+
+ // Handle according to type
+ if (*event.set_sky.type == "regular") {
+ sky->setVisible(true);
+ } else if (*event.set_sky.type == "skybox" &&
+ event.set_sky.params->size() == 6) {
+ sky->setFallbackBgColor(*event.set_sky.bgcolor);
+ skybox = smgr->addSkyBoxSceneNode(
+ texture_src->getTexture((*event.set_sky.params)[0]),
+ texture_src->getTexture((*event.set_sky.params)[1]),
+ texture_src->getTexture((*event.set_sky.params)[2]),
+ texture_src->getTexture((*event.set_sky.params)[3]),
+ texture_src->getTexture((*event.set_sky.params)[4]),
+ texture_src->getTexture((*event.set_sky.params)[5]));
+ }
+ // Handle everything else as plain color
+ else {
+ if (*event.set_sky.type != "plain")
+ infostream << "Unknown sky type: "
+ << (*event.set_sky.type) << std::endl;
+
+ sky->setFallbackBgColor(*event.set_sky.bgcolor);
+ }
+
+ delete event.set_sky.bgcolor;
+ delete event.set_sky.type;
+ delete event.set_sky.params;
+ } else if (event.type == CE_OVERRIDE_DAY_NIGHT_RATIO) {
+ bool enable = event.override_day_night_ratio.do_override;
+ u32 value = event.override_day_night_ratio.ratio_f * 1000;
+ client->getEnv().setDayNightRatioOverride(enable, value);
+ }
+ }
+}
+
+
+void Game::updateCamera(VolatileRunFlags *flags, u32 busy_time,
+ f32 dtime, float time_from_last_punch)
+{
+ LocalPlayer *player = client->getEnv().getLocalPlayer();
+