#include "camera.h"
#include "client.h"
#include "client/tile.h" // For TextureSource
+#include "client/keys.h"
+#include "client/joystick_controller.h"
#include "clientmap.h"
#include "clouds.h"
#include "config.h"
#include "tool.h"
#include "util/directiontables.h"
#include "util/pointedthing.h"
+#include "irrlicht_changes/static_text.h"
#include "version.h"
#include "minimap.h"
#include "mapblock_mesh.h"
std::ostringstream os(std::ios_base::binary);
g_profiler->printPage(os, show_profiler, show_profiler_max);
std::wstring text = utf8_to_wide(os.str());
- guitext_profiler->setText(text.c_str());
+ setStaticText(guitext_profiler, text.c_str());
guitext_profiler->setVisible(true);
s32 w = fe->getTextWidth(text.c_str());
static inline void create_formspec_menu(GUIFormSpecMenu **cur_formspec,
InventoryManager *invmgr, IGameDef *gamedef,
IWritableTextureSource *tsrc, IrrlichtDevice *device,
+ JoystickController *joystick,
IFormSource *fs_src, TextDest *txt_dest, Client *client)
{
if (*cur_formspec == 0) {
- *cur_formspec = new GUIFormSpecMenu(device, guiroot, -1, &g_menumgr,
- invmgr, gamedef, tsrc, fs_src, txt_dest, client);
+ *cur_formspec = new GUIFormSpecMenu(device, joystick,
+ guiroot, -1, &g_menumgr, invmgr, gamedef, tsrc,
+ fs_src, txt_dest, client);
(*cur_formspec)->doPause = false;
/*
static void show_deathscreen(GUIFormSpecMenu **cur_formspec,
InventoryManager *invmgr, IGameDef *gamedef,
- IWritableTextureSource *tsrc, IrrlichtDevice *device, Client *client)
+ IWritableTextureSource *tsrc, IrrlichtDevice *device,
+ JoystickController *joystick, Client *client)
{
std::string formspec =
std::string(FORMSPEC_VERSION_STRING) +
FormspecFormSource *fs_src = new FormspecFormSource(formspec);
LocalFormspecHandler *txt_dst = new LocalFormspecHandler("MT_DEATH_SCREEN", client);
- create_formspec_menu(cur_formspec, invmgr, gamedef, tsrc, device, fs_src, txt_dst, NULL);
+ create_formspec_menu(cur_formspec, invmgr, gamedef, tsrc, device,
+ joystick, fs_src, txt_dst, NULL);
}
/******************************************************************************/
static void show_pause_menu(GUIFormSpecMenu **cur_formspec,
InventoryManager *invmgr, IGameDef *gamedef,
IWritableTextureSource *tsrc, IrrlichtDevice *device,
- bool singleplayermode)
+ JoystickController *joystick, bool singleplayermode)
{
#ifdef __ANDROID__
std::string control_text = strgettext("Default Controls:\n"
FormspecFormSource *fs_src = new FormspecFormSource(os.str());
LocalFormspecHandler *txt_dst = new LocalFormspecHandler("MT_PAUSE_MENU");
- create_formspec_menu(cur_formspec, invmgr, gamedef, tsrc, device, fs_src, txt_dst, NULL);
+ create_formspec_menu(cur_formspec, invmgr, gamedef, tsrc, device,
+ joystick, fs_src, txt_dst, NULL);
std::string con("btn_continue");
(*cur_formspec)->setFocus(con);
(*cur_formspec)->doPause = true;
// Get new messages from error log buffer
while (!chat_log_error_buf.empty()) {
- chat_backend.addMessage(L"", utf8_to_wide(chat_log_error_buf.get()));
+ std::wstring error_message = utf8_to_wide(chat_log_error_buf.get());
+ if (!g_settings->getBool("disable_escape_sequences")) {
+ error_message = L"\x1b(c@red)" + error_message + L"\x1b(c@white)";
+ }
+ chat_backend.addMessage(L"", error_message);
}
// Get new messages from client
// Display all messages in a static text element
unsigned int recent_chat_count = chat_backend.getRecentBuffer().getLineCount();
- std::wstring recent_chat = chat_backend.getRecentChat();
+ EnrichedString recent_chat = chat_backend.getRecentChat();
unsigned int line_height = g_fontengine->getLineHeight();
- guitext_chat->setText(recent_chat.c_str());
+ setStaticText(guitext_chat, recent_chat);
// Update gui element size and position
- s32 chat_y = 5 + line_height;
+ s32 chat_y = 5;
if (show_debug)
- chat_y += line_height;
+ chat_y += 2 * line_height;
// first pass to calculate height of text to be set
- s32 width = std::min(g_fontengine->getTextWidth(recent_chat) + 10,
+ s32 width = std::min(g_fontengine->getTextWidth(recent_chat.c_str()) + 10,
porting::getWindowSize().X - 20);
core::rect<s32> rect(10, chat_y, width, chat_y + porting::getWindowSize().Y);
guitext_chat->setRelativePosition(rect);
{
handler = NULL;
populate();
+ populate_nonchanging();
}
- enum {
- // Player movement
- KEYMAP_ID_FORWARD,
- KEYMAP_ID_BACKWARD,
- KEYMAP_ID_LEFT,
- KEYMAP_ID_RIGHT,
- KEYMAP_ID_JUMP,
- KEYMAP_ID_SPECIAL1,
- KEYMAP_ID_SNEAK,
- KEYMAP_ID_AUTORUN,
-
- // Other
- KEYMAP_ID_DROP,
- KEYMAP_ID_INVENTORY,
- KEYMAP_ID_CHAT,
- KEYMAP_ID_CMD,
- KEYMAP_ID_CONSOLE,
- KEYMAP_ID_MINIMAP,
- KEYMAP_ID_FREEMOVE,
- KEYMAP_ID_FASTMOVE,
- KEYMAP_ID_NOCLIP,
- KEYMAP_ID_CINEMATIC,
- KEYMAP_ID_SCREENSHOT,
- KEYMAP_ID_TOGGLE_HUD,
- KEYMAP_ID_TOGGLE_CHAT,
- KEYMAP_ID_TOGGLE_FORCE_FOG_OFF,
- KEYMAP_ID_TOGGLE_UPDATE_CAMERA,
- KEYMAP_ID_TOGGLE_DEBUG,
- KEYMAP_ID_TOGGLE_PROFILER,
- KEYMAP_ID_CAMERA_MODE,
- KEYMAP_ID_INCREASE_VIEWING_RANGE,
- KEYMAP_ID_DECREASE_VIEWING_RANGE,
- KEYMAP_ID_RANGESELECT,
-
- KEYMAP_ID_QUICKTUNE_NEXT,
- KEYMAP_ID_QUICKTUNE_PREV,
- KEYMAP_ID_QUICKTUNE_INC,
- KEYMAP_ID_QUICKTUNE_DEC,
-
- KEYMAP_ID_DEBUG_STACKS,
-
- // Fake keycode for array size and internal checks
- KEYMAP_INTERNAL_ENUM_COUNT
-
-
- };
-
void populate();
- KeyPress key[KEYMAP_INTERNAL_ENUM_COUNT];
+ // Keys that are not settings dependent
+ void populate_nonchanging();
+
+ KeyPress key[KeyType::INTERNAL_ENUM_COUNT];
InputHandler *handler;
};
+void KeyCache::populate_nonchanging()
+{
+ key[KeyType::ESC] = EscapeKey;
+}
+
void KeyCache::populate()
{
- key[KEYMAP_ID_FORWARD] = getKeySetting("keymap_forward");
- key[KEYMAP_ID_BACKWARD] = getKeySetting("keymap_backward");
- key[KEYMAP_ID_LEFT] = getKeySetting("keymap_left");
- key[KEYMAP_ID_RIGHT] = getKeySetting("keymap_right");
- key[KEYMAP_ID_JUMP] = getKeySetting("keymap_jump");
- key[KEYMAP_ID_SPECIAL1] = getKeySetting("keymap_special1");
- key[KEYMAP_ID_SNEAK] = getKeySetting("keymap_sneak");
-
- key[KEYMAP_ID_AUTORUN] = getKeySetting("keymap_autorun");
-
- key[KEYMAP_ID_DROP] = getKeySetting("keymap_drop");
- key[KEYMAP_ID_INVENTORY] = getKeySetting("keymap_inventory");
- key[KEYMAP_ID_CHAT] = getKeySetting("keymap_chat");
- key[KEYMAP_ID_CMD] = getKeySetting("keymap_cmd");
- key[KEYMAP_ID_CONSOLE] = getKeySetting("keymap_console");
- key[KEYMAP_ID_MINIMAP] = getKeySetting("keymap_minimap");
- key[KEYMAP_ID_FREEMOVE] = getKeySetting("keymap_freemove");
- key[KEYMAP_ID_FASTMOVE] = getKeySetting("keymap_fastmove");
- key[KEYMAP_ID_NOCLIP] = getKeySetting("keymap_noclip");
- key[KEYMAP_ID_CINEMATIC] = getKeySetting("keymap_cinematic");
- key[KEYMAP_ID_SCREENSHOT] = getKeySetting("keymap_screenshot");
- key[KEYMAP_ID_TOGGLE_HUD] = getKeySetting("keymap_toggle_hud");
- key[KEYMAP_ID_TOGGLE_CHAT] = getKeySetting("keymap_toggle_chat");
- key[KEYMAP_ID_TOGGLE_FORCE_FOG_OFF]
+ key[KeyType::FORWARD] = getKeySetting("keymap_forward");
+ key[KeyType::BACKWARD] = getKeySetting("keymap_backward");
+ key[KeyType::LEFT] = getKeySetting("keymap_left");
+ key[KeyType::RIGHT] = getKeySetting("keymap_right");
+ key[KeyType::JUMP] = getKeySetting("keymap_jump");
+ key[KeyType::SPECIAL1] = getKeySetting("keymap_special1");
+ key[KeyType::SNEAK] = getKeySetting("keymap_sneak");
+
+ key[KeyType::AUTORUN] = getKeySetting("keymap_autorun");
+
+ key[KeyType::DROP] = getKeySetting("keymap_drop");
+ key[KeyType::INVENTORY] = getKeySetting("keymap_inventory");
+ key[KeyType::CHAT] = getKeySetting("keymap_chat");
+ key[KeyType::CMD] = getKeySetting("keymap_cmd");
+ key[KeyType::CONSOLE] = getKeySetting("keymap_console");
+ key[KeyType::MINIMAP] = getKeySetting("keymap_minimap");
+ key[KeyType::FREEMOVE] = getKeySetting("keymap_freemove");
+ key[KeyType::FASTMOVE] = getKeySetting("keymap_fastmove");
+ key[KeyType::NOCLIP] = getKeySetting("keymap_noclip");
+ key[KeyType::CINEMATIC] = getKeySetting("keymap_cinematic");
+ key[KeyType::SCREENSHOT] = getKeySetting("keymap_screenshot");
+ key[KeyType::TOGGLE_HUD] = getKeySetting("keymap_toggle_hud");
+ key[KeyType::TOGGLE_CHAT] = getKeySetting("keymap_toggle_chat");
+ key[KeyType::TOGGLE_FORCE_FOG_OFF]
= getKeySetting("keymap_toggle_force_fog_off");
- key[KEYMAP_ID_TOGGLE_UPDATE_CAMERA]
+ key[KeyType::TOGGLE_UPDATE_CAMERA]
= getKeySetting("keymap_toggle_update_camera");
- key[KEYMAP_ID_TOGGLE_DEBUG]
+ key[KeyType::TOGGLE_DEBUG]
= getKeySetting("keymap_toggle_debug");
- key[KEYMAP_ID_TOGGLE_PROFILER]
+ key[KeyType::TOGGLE_PROFILER]
= getKeySetting("keymap_toggle_profiler");
- key[KEYMAP_ID_CAMERA_MODE]
+ key[KeyType::CAMERA_MODE]
= getKeySetting("keymap_camera_mode");
- key[KEYMAP_ID_INCREASE_VIEWING_RANGE]
+ key[KeyType::INCREASE_VIEWING_RANGE]
= getKeySetting("keymap_increase_viewing_range_min");
- key[KEYMAP_ID_DECREASE_VIEWING_RANGE]
+ key[KeyType::DECREASE_VIEWING_RANGE]
= getKeySetting("keymap_decrease_viewing_range_min");
- key[KEYMAP_ID_RANGESELECT]
+ key[KeyType::RANGESELECT]
= getKeySetting("keymap_rangeselect");
- key[KEYMAP_ID_QUICKTUNE_NEXT] = getKeySetting("keymap_quicktune_next");
- key[KEYMAP_ID_QUICKTUNE_PREV] = getKeySetting("keymap_quicktune_prev");
- key[KEYMAP_ID_QUICKTUNE_INC] = getKeySetting("keymap_quicktune_inc");
- key[KEYMAP_ID_QUICKTUNE_DEC] = getKeySetting("keymap_quicktune_dec");
+ key[KeyType::QUICKTUNE_NEXT] = getKeySetting("keymap_quicktune_next");
+ key[KeyType::QUICKTUNE_PREV] = getKeySetting("keymap_quicktune_prev");
+ key[KeyType::QUICKTUNE_INC] = getKeySetting("keymap_quicktune_inc");
+ key[KeyType::QUICKTUNE_DEC] = getKeySetting("keymap_quicktune_dec");
- key[KEYMAP_ID_DEBUG_STACKS] = getKeySetting("keymap_print_debug_stacks");
+ key[KeyType::DEBUG_STACKS] = getKeySetting("keymap_print_debug_stacks");
if (handler) {
// First clear all keys, then re-add the ones we listen for
handler->dontListenForKeys();
- for (size_t i = 0; i < KEYMAP_INTERNAL_ENUM_COUNT; i++) {
+ for (size_t i = 0; i < KeyType::INTERNAL_ENUM_COUNT; i++) {
handler->listenForKey(key[i]);
}
handler->listenForKey(EscapeKey);
f32 dtime);
void updateStats(RunStats *stats, const FpsControl &draw_times, f32 dtime);
+ // Input related
void processUserInput(VolatileRunFlags *flags, GameRunData *runData,
f32 dtime);
- void processKeyboardInput(VolatileRunFlags *flags,
+ void processKeyInput(VolatileRunFlags *flags,
float *statustext_time,
float *jump_timer,
bool *reset_jump_timer,
void decreaseViewRange(float *statustext_time);
void toggleFullViewRange(float *statustext_time);
- void updateCameraDirection(CameraOrientation *cam, VolatileRunFlags *flags);
+ void updateCameraDirection(CameraOrientation *cam, VolatileRunFlags *flags,
+ float dtime);
void updateCameraOrientation(CameraOrientation *cam,
- const VolatileRunFlags &flags);
+ const VolatileRunFlags &flags, float dtime);
void updatePlayerControl(const CameraOrientation &cam);
void step(f32 *dtime);
void processClientEvents(CameraOrientation *cam, float *damage_flash);
static void settingChangedCallback(const std::string &setting_name, void *data);
void readSettings();
+ inline bool getLeftClicked()
+ {
+ return input->getLeftClicked() ||
+ input->joystick.getWasKeyDown(KeyType::MOUSE_L);
+ }
+ inline bool getRightClicked()
+ {
+ return input->getRightClicked() ||
+ input->joystick.getWasKeyDown(KeyType::MOUSE_R);
+ }
+ inline bool isLeftPressed()
+ {
+ return input->getLeftState() ||
+ input->joystick.isKeyDown(KeyType::MOUSE_L);
+ }
+ inline bool isRightPressed()
+ {
+ return input->getRightState() ||
+ input->joystick.isKeyDown(KeyType::MOUSE_R);
+ }
+ inline bool getLeftReleased()
+ {
+ return input->getLeftReleased() ||
+ input->joystick.wasKeyReleased(KeyType::MOUSE_L);
+ }
+
+ inline bool isKeyDown(GameKeyType k)
+ {
+ return input->isKeyDown(keycache.key[k]) || input->joystick.isKeyDown(k);
+ }
+ inline bool wasKeyDown(GameKeyType k)
+ {
+ return input->wasKeyDown(keycache.key[k]) || input->joystick.wasKeyDown(k);
+ }
+
#ifdef __ANDROID__
void handleAndroidChatInput();
#endif
*/
bool m_cache_doubletap_jump;
bool m_cache_enable_clouds;
+ bool m_cache_enable_joysticks;
bool m_cache_enable_particles;
bool m_cache_enable_fog;
f32 m_cache_mouse_sensitivity;
+ f32 m_cache_joystick_frustum_sensitivity;
f32 m_repeat_right_click_time;
#ifdef __ANDROID__
&settingChangedCallback, this);
g_settings->registerChangedCallback("enable_clouds",
&settingChangedCallback, this);
+ g_settings->registerChangedCallback("doubletap_joysticks",
+ &settingChangedCallback, this);
g_settings->registerChangedCallback("enable_particles",
&settingChangedCallback, this);
g_settings->registerChangedCallback("enable_fog",
&settingChangedCallback, this);
g_settings->registerChangedCallback("mouse_sensitivity",
&settingChangedCallback, this);
+ g_settings->registerChangedCallback("joystick_frustum_sensitivity",
+ &settingChangedCallback, this);
g_settings->registerChangedCallback("repeat_rightclick_time",
&settingChangedCallback, this);
updateProfilers(runData, stats, draw_times, dtime);
processUserInput(&flags, &runData, dtime);
// Update camera before player movement to avoid camera lag of one frame
- updateCameraDirection(&cam_view_target, &flags);
+ updateCameraDirection(&cam_view_target, &flags, dtime);
float cam_smoothing = 0;
if (g_settings->getBool("cinematic"))
cam_smoothing = 1 - g_settings->getFloat("cinematic_camera_smoothing");
/* Set window caption
*/
std::wstring str = utf8_to_wide(PROJECT_NAME_C);
+ str += L" ";
+ str += utf8_to_wide(g_version_hash);
str += L" [";
str += driver->getName();
str += L"]";
bool Game::initGui()
{
// First line of debug text
- guitext = guienv->addStaticText(
+ guitext = addStaticText(guienv,
utf8_to_wide(PROJECT_NAME_C).c_str(),
core::rect<s32>(0, 0, 0, 0),
false, false, guiroot);
// Second line of debug text
- guitext2 = guienv->addStaticText(
+ guitext2 = addStaticText(guienv,
L"",
core::rect<s32>(0, 0, 0, 0),
false, false, guiroot);
// At the middle of the screen
// Object infos are shown in this
- guitext_info = guienv->addStaticText(
+ guitext_info = addStaticText(guienv,
L"",
core::rect<s32>(0, 0, 400, g_fontengine->getTextHeight() * 5 + 5) + v2s32(100, 200),
false, true, guiroot);
// Status text (displays info when showing and hiding GUI stuff, etc.)
- guitext_status = guienv->addStaticText(
+ guitext_status = addStaticText(guienv,
L"<Status>",
core::rect<s32>(0, 0, 0, 0),
false, false, guiroot);
guitext_status->setVisible(false);
// Chat text
- guitext_chat = guienv->addStaticText(
+ guitext_chat = addStaticText(
+ guienv,
L"",
core::rect<s32>(0, 0, 0, 0),
//false, false); // Disable word wrap as of now
false, true, guiroot);
+
// Remove stale "recent" chat messages from previous connections
chat_backend->clearRecentChat();
}
// Profiler text (size is updated when text is updated)
- guitext_profiler = guienv->addStaticText(
+ guitext_profiler = addStaticText(guienv,
L"<Profiler>",
core::rect<s32>(0, 0, 0, 0),
false, false, guiroot);
break;
}
- if (input->wasKeyDown(EscapeKey) || input->wasKeyDown(CancelKey)) {
+ if (wasKeyDown(KeyType::ESC) || input->wasKeyDown(CancelKey)) {
*aborted = true;
infostream << "Connect aborted [Escape]" << std::endl;
break;
return false;
}
- if (input->wasKeyDown(EscapeKey) || input->wasKeyDown(CancelKey)) {
+ if (wasKeyDown(KeyType::ESC) || input->wasKeyDown(CancelKey)) {
*aborted = true;
infostream << "Connect aborted [Escape]" << std::endl;
return false;
if (m_cache_doubletap_jump && runData->jump_timer <= 0.2)
runData->jump_timer += dtime;
- processKeyboardInput(
+ processKeyInput(
flags,
&runData->statustext_time,
&runData->jump_timer,
}
-void Game::processKeyboardInput(VolatileRunFlags *flags,
+void Game::processKeyInput(VolatileRunFlags *flags,
float *statustext_time,
float *jump_timer,
bool *reset_jump_timer,
//TimeTaker tt("process kybd input", NULL, PRECISION_NANO);
- if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_DROP])) {
+ if (wasKeyDown(KeyType::DROP)) {
dropSelectedItem();
- } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_AUTORUN])) {
+ } else if (wasKeyDown(KeyType::AUTORUN)) {
toggleAutorun(statustext_time);
- } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_INVENTORY])) {
+ } else if (wasKeyDown(KeyType::INVENTORY)) {
openInventory();
- } else if (input->wasKeyDown(EscapeKey) || input->wasKeyDown(CancelKey)) {
+ } else if (wasKeyDown(KeyType::ESC) || input->wasKeyDown(CancelKey)) {
if (!gui_chat_console->isOpenInhibited()) {
show_pause_menu(¤t_formspec, client, gamedef,
- texture_src, device, simple_singleplayer_mode);
+ texture_src, device, &input->joystick,
+ simple_singleplayer_mode);
}
- } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_CHAT])) {
+ } else if (wasKeyDown(KeyType::CHAT)) {
openConsole(0.2, L"");
- } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_CMD])) {
+ } else if (wasKeyDown(KeyType::CMD)) {
openConsole(0.2, L"/");
- } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_CONSOLE])) {
+ } else if (wasKeyDown(KeyType::CONSOLE)) {
openConsole(1);
- } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_FREEMOVE])) {
+ } else if (wasKeyDown(KeyType::FREEMOVE)) {
toggleFreeMove(statustext_time);
- } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_JUMP])) {
+ } else if (wasKeyDown(KeyType::JUMP)) {
toggleFreeMoveAlt(statustext_time, jump_timer);
*reset_jump_timer = true;
- } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_FASTMOVE])) {
+ } else if (wasKeyDown(KeyType::FASTMOVE)) {
toggleFast(statustext_time);
- } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_NOCLIP])) {
+ } else if (wasKeyDown(KeyType::NOCLIP)) {
toggleNoClip(statustext_time);
- } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_CINEMATIC])) {
+ } else if (wasKeyDown(KeyType::CINEMATIC)) {
toggleCinematic(statustext_time);
- } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_SCREENSHOT])) {
+ } else if (wasKeyDown(KeyType::SCREENSHOT)) {
client->makeScreenshot(device);
- } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_TOGGLE_HUD])) {
+ } else if (wasKeyDown(KeyType::TOGGLE_HUD)) {
toggleHud(statustext_time, &flags->show_hud);
- } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_MINIMAP])) {
+ } else if (wasKeyDown(KeyType::MINIMAP)) {
toggleMinimap(statustext_time, &flags->show_minimap, flags->show_hud,
- input->isKeyDown(keycache.key[KeyCache::KEYMAP_ID_SNEAK]));
- } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_TOGGLE_CHAT])) {
+ isKeyDown(KeyType::SNEAK));
+ } else if (wasKeyDown(KeyType::TOGGLE_CHAT)) {
toggleChat(statustext_time, &flags->show_chat);
- } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_TOGGLE_FORCE_FOG_OFF])) {
+ } else if (wasKeyDown(KeyType::TOGGLE_FORCE_FOG_OFF)) {
toggleFog(statustext_time, &flags->force_fog_off);
- } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_TOGGLE_UPDATE_CAMERA])) {
+ } else if (wasKeyDown(KeyType::TOGGLE_UPDATE_CAMERA)) {
toggleUpdateCamera(statustext_time, &flags->disable_camera_update);
- } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_TOGGLE_DEBUG])) {
+ } else if (wasKeyDown(KeyType::TOGGLE_DEBUG)) {
toggleDebug(statustext_time, &flags->show_debug, &flags->show_profiler_graph);
- } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_TOGGLE_PROFILER])) {
+ } else if (wasKeyDown(KeyType::TOGGLE_PROFILER)) {
toggleProfiler(statustext_time, profiler_current_page, profiler_max_page);
- } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_INCREASE_VIEWING_RANGE])) {
+ } else if (wasKeyDown(KeyType::INCREASE_VIEWING_RANGE)) {
increaseViewRange(statustext_time);
- } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_DECREASE_VIEWING_RANGE])) {
+ } else if (wasKeyDown(KeyType::DECREASE_VIEWING_RANGE)) {
decreaseViewRange(statustext_time);
- } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_RANGESELECT])) {
+ } else if (wasKeyDown(KeyType::RANGESELECT)) {
toggleFullViewRange(statustext_time);
- } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_QUICKTUNE_NEXT])) {
+ } else if (wasKeyDown(KeyType::QUICKTUNE_NEXT)) {
quicktune->next();
- } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_QUICKTUNE_PREV])) {
+ } else if (wasKeyDown(KeyType::QUICKTUNE_PREV)) {
quicktune->prev();
- } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_QUICKTUNE_INC])) {
+ } else if (wasKeyDown(KeyType::QUICKTUNE_INC)) {
quicktune->inc();
- } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_QUICKTUNE_DEC])) {
+ } else if (wasKeyDown(KeyType::QUICKTUNE_DEC)) {
quicktune->dec();
- } else if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_DEBUG_STACKS])) {
+ } else if (wasKeyDown(KeyType::DEBUG_STACKS)) {
// Print debug stacks
dstream << "-----------------------------------------"
<< std::endl;
debug_stacks_print();
}
- if (!input->isKeyDown(getKeySetting("keymap_jump")) && *reset_jump_timer) {
+ if (!isKeyDown(KeyType::JUMP) && *reset_jump_timer) {
*reset_jump_timer = false;
*jump_timer = 0.0;
}
}
}
-
void Game::processItemSelection(u16 *new_playeritem)
{
LocalPlayer *player = client->getEnv().getLocalPlayer();
u16 max_item = MYMIN(PLAYER_INVENTORY_SIZE - 1,
player->hud_hotbar_itemcount - 1);
- if (wheel < 0)
+ s32 dir = wheel;
+
+ if (input->joystick.wasKeyDown(KeyType::SCROLL_DOWN)) {
+ dir = -1;
+ }
+
+ if (input->joystick.wasKeyDown(KeyType::SCROLL_UP)) {
+ dir = 1;
+ }
+
+ if (dir < 0)
*new_playeritem = *new_playeritem < max_item ? *new_playeritem + 1 : 0;
- else if (wheel > 0)
+ else if (dir > 0)
*new_playeritem = *new_playeritem > 0 ? *new_playeritem - 1 : max_item;
- // else wheel == 0
-
+ // else dir == 0
/* Item selection using keyboard
*/
TextDest *txt_dst = new TextDestPlayerInventory(client);
create_formspec_menu(¤t_formspec, client, gamedef, texture_src,
- device, fs_src, txt_dst, client);
+ device, &input->joystick, fs_src, txt_dst, client);
InventoryLocation inventoryloc;
inventoryloc.setCurrentPlayer();
void Game::updateCameraDirection(CameraOrientation *cam,
- VolatileRunFlags *flags)
+ VolatileRunFlags *flags, float dtime)
{
if ((device->isWindowActive() && noMenuActive()) || random_input) {
if (flags->first_loop_after_window_activation)
flags->first_loop_after_window_activation = false;
else
- updateCameraOrientation(cam, *flags);
+ updateCameraOrientation(cam, *flags, dtime);
input->setMousePos((driver->getScreenSize().Width / 2),
(driver->getScreenSize().Height / 2));
}
}
-
void Game::updateCameraOrientation(CameraOrientation *cam,
- const VolatileRunFlags &flags)
+ const VolatileRunFlags &flags, float dtime)
{
#ifdef HAVE_TOUCHSCREENGUI
if (g_touchscreengui) {
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);
}
#endif
+ if (m_cache_enable_joysticks) {
+ f32 c = m_cache_joystick_frustum_sensitivity * (1.f / 32767.f) * dtime;
+ cam->camera_yaw -= input->joystick.getAxisWithoutDead(JA_FRUSTUM_HORIZONTAL) *
+ c;
+ cam->camera_pitch += input->joystick.getAxisWithoutDead(JA_FRUSTUM_VERTICAL) *
+ c;
+ }
+
cam->camera_pitch = rangelim(cam->camera_pitch, -89.5, 89.5);
}
{
//TimeTaker tt("update player control", NULL, PRECISION_NANO);
+ // DO NOT use the isKeyDown method for the forward, backward, left, right
+ // buttons, as the code that uses the controls needs to be able to
+ // distinguish between the two in order to know when to use joysticks.
+
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(),
+ input->isKeyDown(keycache.key[KeyType::FORWARD]),
+ input->isKeyDown(keycache.key[KeyType::BACKWARD]),
+ input->isKeyDown(keycache.key[KeyType::LEFT]),
+ input->isKeyDown(keycache.key[KeyType::RIGHT]),
+ isKeyDown(KeyType::JUMP),
+ isKeyDown(KeyType::SPECIAL1),
+ isKeyDown(KeyType::SNEAK),
+ isLeftPressed(),
+ isRightPressed(),
cam.camera_pitch,
- cam.camera_yaw
+ cam.camera_yaw,
+ input->joystick.getAxisWithoutDead(JA_SIDEWARD_MOVE),
+ input->joystick.getAxisWithoutDead(JA_FORWARD_MOVE)
);
u32 keypress_bits =
- ( (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
+ ( (u32)(isKeyDown(KeyType::FORWARD) & 0x1) << 0) |
+ ( (u32)(isKeyDown(KeyType::BACKWARD) & 0x1) << 1) |
+ ( (u32)(isKeyDown(KeyType::LEFT) & 0x1) << 2) |
+ ( (u32)(isKeyDown(KeyType::RIGHT) & 0x1) << 3) |
+ ( (u32)(isKeyDown(KeyType::JUMP) & 0x1) << 4) |
+ ( (u32)(isKeyDown(KeyType::SPECIAL1) & 0x1) << 5) |
+ ( (u32)(isKeyDown(KeyType::SNEAK) & 0x1) << 6) |
+ ( (u32)(isLeftPressed() & 0x1) << 7) |
+ ( (u32)(isRightPressed() & 0x1) << 8
);
#ifdef ANDROID
cam->camera_pitch = event.player_force_move.pitch;
} else if (event.type == CE_DEATHSCREEN) {
show_deathscreen(¤t_formspec, client, gamedef, texture_src,
- device, client);
+ device, &input->joystick, client);
chat_backend->addMessage(L"", L"You died.");
new TextDestPlayerInventory(client, *(event.show_formspec.formname));
create_formspec_menu(¤t_formspec, client, gamedef,
- texture_src, device, fs_src, txt_dst, client);
+ texture_src, device, &input->joystick,
+ fs_src, txt_dst, client);
delete(event.show_formspec.formspec);
delete(event.show_formspec.formname);
v3s16 old_camera_offset = camera->getOffset();
- if (input->wasKeyDown(keycache.key[KeyCache::KEYMAP_ID_CAMERA_MODE])) {
+ if (wasKeyDown(KeyType::CAMERA_MODE)) {
GenericCAO *playercao = player->getCAO();
// If playercao not loaded, don't change camera
- pointing away from node
*/
if (runData->digging) {
- if (input->getLeftReleased()) {
+ if (getLeftReleased()) {
infostream << "Left button released"
<< " (stopped digging)" << std::endl;
runData->digging = false;
}
}
- if (!runData->digging && runData->ldown_for_dig && !input->getLeftState()) {
+ if (!runData->digging && runData->ldown_for_dig && !isLeftPressed()) {
runData->ldown_for_dig = false;
}
soundmaker->m_player_leftpunch_sound.name = "";
- if (input->getRightState())
+ if (isRightPressed())
runData->repeat_rightclick_timer += dtime;
else
runData->repeat_rightclick_timer = 0;
- if (playeritem_def.usable && input->getLeftState()) {
- if (input->getLeftClicked())
+ if (playeritem_def.usable && isLeftPressed()) {
+ if (getLeftClicked())
client->interact(4, pointed);
} else if (pointed.type == POINTEDTHING_NODE) {
ToolCapabilities playeritem_toolcap =
} else if (pointed.type == POINTEDTHING_OBJECT) {
handlePointingAtObject(runData, pointed, playeritem,
player_position, show_debug);
- } else if (input->getLeftState()) {
+ } else if (isLeftPressed()) {
// When button is held down in air, show continuous animation
runData->left_punch = true;
- } else if (input->getRightClicked()) {
+ } else if (getRightClicked()) {
handlePointingAtNothing(runData, playeritem);
}
runData->pointed_old = pointed;
- if (runData->left_punch || input->getLeftClicked())
+ if (runData->left_punch || getLeftClicked())
camera->setDigging(0); // left click animation
input->resetLeftClicked();
input->resetRightClicked();
+ input->joystick.clearWasKeyDown(KeyType::MOUSE_L);
+ input->joystick.clearWasKeyDown(KeyType::MOUSE_R);
+
input->resetLeftReleased();
input->resetRightReleased();
+
+ input->joystick.clearWasKeyReleased(KeyType::MOUSE_L);
+ input->joystick.clearWasKeyReleased(KeyType::MOUSE_R);
}
}
}
- if (runData->nodig_delay_timer <= 0.0 && input->getLeftState()
+ if (runData->nodig_delay_timer <= 0.0 && isLeftPressed()
&& client->checkPrivilege("interact")) {
handleDigging(runData, pointed, nodepos, playeritem_toolcap, dtime);
}
- if ((input->getRightClicked() ||
+ if ((getRightClicked() ||
runData->repeat_rightclick_timer >= m_repeat_right_click_time) &&
client->checkPrivilege("interact")) {
runData->repeat_rightclick_timer = 0;
infostream << "Ground right-clicked" << std::endl;
if (meta && meta->getString("formspec") != "" && !random_input
- && !input->isKeyDown(getKeySetting("keymap_sneak"))) {
+ && !isKeyDown(KeyType::SNEAK)) {
infostream << "Launching custom inventory view" << std::endl;
InventoryLocation inventoryloc;
TextDest *txt_dst = new TextDestNodeMetadata(nodepos, client);
create_formspec_menu(¤t_formspec, client, gamedef,
- texture_src, device, fs_src, txt_dst, client);
+ texture_src, device, &input->joystick, fs_src, txt_dst, client);
current_formspec->setFormSpec(meta->getString("formspec"), inventoryloc);
} else {
runData->selected_object->debugInfoText()));
}
- if (input->getLeftState()) {
+ if (isLeftPressed()) {
bool do_punch = false;
bool do_punch_damage = false;
runData->object_hit_delay_timer = object_hit_delay;
}
- if (input->getLeftClicked())
+ if (getLeftClicked())
do_punch = true;
if (do_punch) {
if (!disable_send)
client->interact(0, pointed);
}
- } else if (input->getRightClicked()) {
+ } else if (getRightClicked()) {
infostream << "Right-clicked object" << std::endl;
client->interact(3, pointed); // place
}
<< ", v_range = " << draw_control->wanted_range
<< std::setprecision(3)
<< ", RTT = " << client->getRTT();
- guitext->setText(utf8_to_wide(os.str()).c_str());
- guitext->setVisible(true);
- } else if (flags.show_hud || flags.show_chat) {
- std::ostringstream os(std::ios_base::binary);
- os << PROJECT_NAME_C " " << g_version_hash;
- guitext->setText(utf8_to_wide(os.str()).c_str());
+ setStaticText(guitext, utf8_to_wide(os.str()).c_str());
guitext->setVisible(true);
} else {
guitext->setVisible(false);
}
}
- guitext2->setText(utf8_to_wide(os.str()).c_str());
+ setStaticText(guitext2, utf8_to_wide(os.str()).c_str());
guitext2->setVisible(true);
core::rect<s32> rect(
guitext2->setVisible(false);
}
- guitext_info->setText(infotext.c_str());
+ setStaticText(guitext_info, infotext.c_str());
guitext_info->setVisible(flags.show_hud && g_menumgr.menuCount() == 0);
float statustext_time_max = 1.5;
}
}
- guitext_status->setText(statustext.c_str());
+ setStaticText(guitext_status, statustext.c_str());
guitext_status->setVisible(!statustext.empty());
if (!statustext.empty()) {
void Game::readSettings()
{
- m_cache_doubletap_jump = g_settings->getBool("doubletap_jump");
- m_cache_enable_clouds = g_settings->getBool("enable_clouds");
- m_cache_enable_particles = g_settings->getBool("enable_particles");
- m_cache_enable_fog = g_settings->getBool("enable_fog");
- m_cache_mouse_sensitivity = g_settings->getFloat("mouse_sensitivity");
- m_repeat_right_click_time = g_settings->getFloat("repeat_rightclick_time");
+ m_cache_doubletap_jump = g_settings->getBool("doubletap_jump");
+ m_cache_enable_clouds = g_settings->getBool("enable_clouds");
+ m_cache_enable_joysticks = g_settings->getBool("enable_joysticks");
+ m_cache_enable_particles = g_settings->getBool("enable_particles");
+ m_cache_enable_fog = g_settings->getBool("enable_fog");
+ m_cache_mouse_sensitivity = g_settings->getFloat("mouse_sensitivity");
+ m_cache_joystick_frustum_sensitivity = g_settings->getFloat("joystick_frustum_sensitivity");
+ m_repeat_right_click_time = g_settings->getFloat("repeat_rightclick_time");
m_cache_mouse_sensitivity = rangelim(m_cache_mouse_sensitivity, 0.001, 100.0);
}
projects / minetest.git / blobdiff