+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::updateProfilers(const GameRunData &run_data, const RunStats &stats,
+ const FpsControl &draw_times, f32 dtime)
+{
+ float profiler_print_interval =
+ g_settings->getFloat("profiler_print_interval");
+ bool print_to_log = true;
+
+ if (profiler_print_interval == 0) {
+ print_to_log = false;
+ profiler_print_interval = 5;
+ }
+
+ if (profiler_interval.step(dtime, profiler_print_interval)) {
+ if (print_to_log) {
+ infostream << "Profiler:" << std::endl;
+ g_profiler->print(infostream);
+ }
+
+ update_profiler_gui(guitext_profiler, g_fontengine,
+ run_data.profiler_current_page, run_data.profiler_max_page);
+
+ g_profiler->clear();
+ }
+
+ addProfilerGraphs(stats, draw_times, dtime);
+}
+
+
+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];
+ if (g_settings->getBool("enable_node_highlighting"))
+ 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, g_fontengine, *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) {
+ cam->camera_yaw = g_touchscreengui->getYaw();
+ cam->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();
+
+ /*
+ For interaction purposes, get info about the held item
+ - What item is it?
+ - Is it a usable item?
+ - Can it point to liquids?
+ */
+ ItemStack playeritem;
+ {
+ InventoryList *mlist = local_inventory->getList("main");
+
+ if (mlist && client->getPlayerItem() < mlist->getSize())
+ playeritem = mlist->getItem(client->getPlayerItem());
+ }
+
+ ToolCapabilities playeritem_toolcap =
+ playeritem.getToolCapabilities(itemdef_manager);
+
+ v3s16 old_camera_offset = camera->getOffset();
+
+ if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_CAMERA_MODE])) {
+ camera->toggleCameraMode();
+ GenericCAO *playercao = player->getCAO();
+
+ assert(playercao != NULL);
+
+ playercao->setVisible(camera->getCameraMode() > CAMERA_MODE_FIRST);
+ }
+
+ float full_punch_interval = playeritem_toolcap.full_punch_interval;
+ float tool_reload_ratio = time_from_last_punch / full_punch_interval;
+
+ tool_reload_ratio = MYMIN(tool_reload_ratio, 1.0);
+ camera->update(player, dtime, busy_time / 1000.0f, tool_reload_ratio,
+ client->getEnv());
+ camera->step(dtime);
+
+ v3f camera_position = camera->getPosition();
+ v3f camera_direction = camera->getDirection();
+ f32 camera_fov = camera->getFovMax();
+ v3s16 camera_offset = camera->getOffset();
+
+ flags->camera_offset_changed = (camera_offset != old_camera_offset);
+
+ if (!flags->disable_camera_update) {
+ client->getEnv().getClientMap().updateCamera(camera_position,
+ camera_direction, camera_fov, camera_offset);
+
+ if (flags->camera_offset_changed) {
+ client->updateCameraOffset(camera_offset);
+ client->getEnv().updateCameraOffset(camera_offset);
+
+ if (clouds)
+ clouds->updateCameraOffset(camera_offset);
+ }
+ }
+}
+
+
+void Game::updateSound(f32 dtime)
+{
+ // Update sound listener
+ v3s16 camera_offset = camera->getOffset();
+ sound->updateListener(camera->getCameraNode()->getPosition() + intToFloat(camera_offset, BS),
+ v3f(0, 0, 0), // velocity
+ camera->getDirection(),
+ camera->getCameraNode()->getUpVector());
+ sound->setListenerGain(g_settings->getFloat("sound_volume"));
+
+
+ // Update sound maker
+ soundmaker->step(dtime);
+
+ LocalPlayer *player = client->getEnv().getLocalPlayer();
+
+ ClientMap &map = client->getEnv().getClientMap();
+ MapNode n = map.getNodeNoEx(player->getStandingNodePos());
+ soundmaker->m_player_step_sound = nodedef_manager->get(n).sound_footstep;
+}
+
+
+void Game::processPlayerInteraction(std::vector<aabb3f> &highlight_boxes,
+ GameRunData *runData, f32 dtime, bool show_hud, bool show_debug)
+{
+ LocalPlayer *player = client->getEnv().getLocalPlayer();
+
+ ItemStack playeritem;
+ {
+ InventoryList *mlist = local_inventory->getList("main");
+
+ if (mlist && client->getPlayerItem() < mlist->getSize())
+ playeritem = mlist->getItem(client->getPlayerItem());
+ }
+
+ const ItemDefinition &playeritem_def =
+ playeritem.getDefinition(itemdef_manager);
+
+ v3f player_position = player->getPosition();
+ v3f camera_position = camera->getPosition();
+ v3f camera_direction = camera->getDirection();
+ v3s16 camera_offset = camera->getOffset();
+
+
+ /*
+ Calculate what block is the crosshair pointing to
+ */
+
+ f32 d = playeritem_def.range; // max. distance
+ f32 d_hand = itemdef_manager->get("").range;
+
+ if (d < 0 && d_hand >= 0)
+ d = d_hand;
+ else if (d < 0)
+ d = 4.0;
+
+ core::line3d<f32> shootline;
+
+ if (camera->getCameraMode() != CAMERA_MODE_THIRD_FRONT) {
+
+ shootline = core::line3d<f32>(camera_position,
+ camera_position + camera_direction * BS * (d + 1));
+
+ } else {
+ // prevent player pointing anything in front-view
+ if (camera->getCameraMode() == CAMERA_MODE_THIRD_FRONT)
+ shootline = core::line3d<f32>(0, 0, 0, 0, 0, 0);
+ }
+
+#ifdef HAVE_TOUCHSCREENGUI
+
+ if ((g_settings->getBool("touchtarget")) && (g_touchscreengui)) {
+ shootline = g_touchscreengui->getShootline();
+ shootline.start += intToFloat(camera_offset, BS);
+ shootline.end += intToFloat(camera_offset, BS);
+ }
+
+#endif
+
+ PointedThing pointed = getPointedThing(
+ // input
+ client, player_position, camera_direction,
+ camera_position, shootline, d,
+ playeritem_def.liquids_pointable,
+ !runData->ldown_for_dig,
+ camera_offset,
+ // output
+ highlight_boxes,
+ runData->selected_object);
+
+ if (pointed != runData->pointed_old) {
+ infostream << "Pointing at " << pointed.dump() << std::endl;
+
+ if (g_settings->getBool("enable_node_highlighting")) {
+ if (pointed.type == POINTEDTHING_NODE) {
+ client->setHighlighted(pointed.node_undersurface, show_hud);
+ } else {
+ client->setHighlighted(pointed.node_undersurface, false);