diff options
author | Loic Blot <loic.blot@unix-experience.fr> | 2015-02-10 21:14:24 +0100 |
---|---|---|
committer | Loic Blot <loic.blot@unix-experience.fr> | 2015-02-12 15:00:03 +0100 |
commit | 146f77fdb750833c649de7159a0833c398e14a4d (patch) | |
tree | 05314d9cae6215ecd418e98fa4fe8e31b2632f0c /src/client | |
parent | 92d1985802b9b5c8a8ca3540221b078fcaadb697 (diff) | |
download | minetest-146f77fdb750833c649de7159a0833c398e14a4d.tar.gz minetest-146f77fdb750833c649de7159a0833c398e14a4d.tar.bz2 minetest-146f77fdb750833c649de7159a0833c398e14a4d.zip |
main.cpp rework * Move ClientLauncher class to a dedicated file * ClientLauncher now owns print_video_modes and speed_tests functions (they are only called by him) * Move GameParams to shared/gameparams.h because it's shared between server and client and launcher need to know it * Move InputHandlers class to client/inputhandler.h * Cleanup includes
Diffstat (limited to 'src/client')
-rw-r--r-- | src/client/clientlauncher.cpp | 707 | ||||
-rw-r--r-- | src/client/clientlauncher.h | 129 | ||||
-rw-r--r-- | src/client/inputhandler.h | 428 |
3 files changed, 1264 insertions, 0 deletions
diff --git a/src/client/clientlauncher.cpp b/src/client/clientlauncher.cpp new file mode 100644 index 000000000..9c5090de3 --- /dev/null +++ b/src/client/clientlauncher.cpp @@ -0,0 +1,707 @@ +/* +Minetest +Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com> + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation; either version 2.1 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public License along +with this program; if not, write to the Free Software Foundation, Inc., +51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#include "main.h" +#include "mainmenumanager.h" +#include "debug.h" +#include "clouds.h" +#include "server.h" +#include "filesys.h" +#include "guiMainMenu.h" +#include "game.h" +#include "chat.h" +#include "gettext.h" +#include "profiler.h" +#include "log.h" +#include "serverlist.h" +#include "guiEngine.h" +#include "player.h" +#include "fontengine.h" +#include "clientlauncher.h" + +// A pointer to a global instance of the time getter +// TODO: why? +TimeGetter *g_timegetter = NULL; + +u32 getTimeMs() +{ + if (g_timegetter == NULL) + return 0; + return g_timegetter->getTime(PRECISION_MILLI); +} + +u32 getTime(TimePrecision prec) { + if (g_timegetter == NULL) + return 0; + return g_timegetter->getTime(prec); +} + +ClientLauncher::~ClientLauncher() +{ + if (receiver) + delete receiver; + + if (input) + delete input; + + if (g_fontengine) + delete g_fontengine; + + if (device) + device->drop(); +} + + +bool ClientLauncher::run(GameParams &game_params, const Settings &cmd_args) +{ + init_args(game_params, cmd_args); + + // List video modes if requested + if (list_video_modes) + return print_video_modes(); + + if (!init_engine(game_params.log_level)) { + errorstream << "Could not initialize game engine." << std::endl; + return false; + } + + // Speed tests (done after irrlicht is loaded to get timer) + if (cmd_args.getFlag("speedtests")) { + dstream << "Running speed tests" << std::endl; + speed_tests(); + return true; + } + + video::IVideoDriver *video_driver = device->getVideoDriver(); + if (video_driver == NULL) { + errorstream << "Could not initialize video driver." << std::endl; + return false; + } + + porting::setXorgClassHint(video_driver->getExposedVideoData(), "Minetest"); + + /* + This changes the minimum allowed number of vertices in a VBO. + Default is 500. + */ + //driver->setMinHardwareBufferVertexCount(50); + + // Create time getter + g_timegetter = new IrrlichtTimeGetter(device); + + // Create game callback for menus + g_gamecallback = new MainGameCallback(device); + + device->setResizable(true); + + if (random_input) + input = new RandomInputHandler(); + else + input = new RealInputHandler(device, receiver); + + smgr = device->getSceneManager(); + + guienv = device->getGUIEnvironment(); + skin = guienv->getSkin(); + skin->setColor(gui::EGDC_BUTTON_TEXT, video::SColor(255, 255, 255, 255)); + skin->setColor(gui::EGDC_3D_HIGH_LIGHT, video::SColor(255, 0, 0, 0)); + skin->setColor(gui::EGDC_3D_SHADOW, video::SColor(255, 0, 0, 0)); + skin->setColor(gui::EGDC_HIGH_LIGHT, video::SColor(255, 70, 100, 50)); + skin->setColor(gui::EGDC_HIGH_LIGHT_TEXT, video::SColor(255, 255, 255, 255)); + + g_fontengine = new FontEngine(g_settings, guienv); + assert(g_fontengine != NULL); + +#if (IRRLICHT_VERSION_MAJOR >= 1 && IRRLICHT_VERSION_MINOR >= 8) || IRRLICHT_VERSION_MAJOR >= 2 + // Irrlicht 1.8 input colours + skin->setColor(gui::EGDC_EDITABLE, video::SColor(255, 128, 128, 128)); + skin->setColor(gui::EGDC_FOCUSED_EDITABLE, video::SColor(255, 96, 134, 49)); +#endif + + // Create the menu clouds + if (!g_menucloudsmgr) + g_menucloudsmgr = smgr->createNewSceneManager(); + if (!g_menuclouds) + g_menuclouds = new Clouds(g_menucloudsmgr->getRootSceneNode(), + g_menucloudsmgr, -1, rand(), 100); + g_menuclouds->update(v2f(0, 0), video::SColor(255, 200, 200, 255)); + scene::ICameraSceneNode* camera; + camera = g_menucloudsmgr->addCameraSceneNode(0, + v3f(0, 0, 0), v3f(0, 60, 100)); + camera->setFarValue(10000); + + /* + GUI stuff + */ + + ChatBackend chat_backend; + + // If an error occurs, this is set to something by menu(). + // It is then displayed before the menu shows on the next call to menu() + std::wstring error_message = L""; + + bool first_loop = true; + + /* + Menu-game loop + */ + bool retval = true; + bool *kill = porting::signal_handler_killstatus(); + + while (device->run() && !*kill && !g_gamecallback->shutdown_requested) + { + // Set the window caption + const wchar_t *text = wgettext("Main Menu"); + device->setWindowCaption((std::wstring(L"Minetest [") + text + L"]").c_str()); + delete[] text; + + try { // This is used for catching disconnects + + guienv->clear(); + + /* + We need some kind of a root node to be able to add + custom gui elements directly on the screen. + Otherwise they won't be automatically drawn. + */ + guiroot = guienv->addStaticText(L"", core::rect<s32>(0, 0, 10000, 10000)); + + bool game_has_run = launch_game(&error_message, game_params, cmd_args); + + // If skip_main_menu, we only want to startup once + if (skip_main_menu && !first_loop) + break; + + first_loop = false; + + if (!game_has_run) { + if (skip_main_menu) + break; + else + continue; + } + + // Break out of menu-game loop to shut down cleanly + if (!device->run() || *kill) { + if (g_settings_path != "") + g_settings->updateConfigFile(g_settings_path.c_str()); + break; + } + + if (current_playername.length() > PLAYERNAME_SIZE-1) { + error_message = wgettext("Player name too long."); + playername = current_playername.substr(0, PLAYERNAME_SIZE-1); + g_settings->set("name", playername); + continue; + } + + device->getVideoDriver()->setTextureCreationFlag( + video::ETCF_CREATE_MIP_MAPS, g_settings->getBool("mip_map")); + +#ifdef HAVE_TOUCHSCREENGUI + receiver->m_touchscreengui = new TouchScreenGUI(device, receiver); + g_touchscreengui = receiver->m_touchscreengui; +#endif + the_game( + kill, + random_input, + input, + device, + worldspec.path, + current_playername, + current_password, + current_address, + current_port, + error_message, + chat_backend, + gamespec, + simple_singleplayer_mode + ); + smgr->clear(); + +#ifdef HAVE_TOUCHSCREENGUI + delete g_touchscreengui; + g_touchscreengui = NULL; + receiver->m_touchscreengui = NULL; +#endif + + } //try + catch (con::PeerNotFoundException &e) { + error_message = wgettext("Connection error (timed out?)"); + errorstream << wide_to_narrow(error_message) << std::endl; + } + +#ifdef NDEBUG + catch (std::exception &e) { + std::string narrow_message = "Some exception: \""; + narrow_message += e.what(); + narrow_message += "\""; + errorstream << narrow_message << std::endl; + error_message = narrow_to_wide(narrow_message); + } +#endif + + // If no main menu, show error and exit + if (skip_main_menu) { + if (error_message != L"") { + verbosestream << "error_message = " + << wide_to_narrow(error_message) << std::endl; + retval = false; + } + break; + } + } // Menu-game loop + + g_menuclouds->drop(); + g_menucloudsmgr->drop(); + + return retval; +} + +void ClientLauncher::init_args(GameParams &game_params, const Settings &cmd_args) +{ + + skip_main_menu = cmd_args.getFlag("go"); + + // FIXME: This is confusing (but correct) + + /* If world_path is set then override it unless skipping the main menu using + * the --go command line param. Else, give preference to the address + * supplied on the command line + */ + address = g_settings->get("address"); + if (game_params.world_path != "" && !skip_main_menu) + address = ""; + else if (cmd_args.exists("address")) + address = cmd_args.get("address"); + + playername = g_settings->get("name"); + if (cmd_args.exists("name")) + playername = cmd_args.get("name"); + + list_video_modes = cmd_args.getFlag("videomodes"); + + use_freetype = g_settings->getBool("freetype"); + + random_input = g_settings->getBool("random_input") + || cmd_args.getFlag("random-input"); +} + +bool ClientLauncher::init_engine(int log_level) +{ + receiver = new MyEventReceiver(); + create_engine_device(log_level); + return device != NULL; +} + +bool ClientLauncher::launch_game(std::wstring *error_message, + GameParams &game_params, const Settings &cmd_args) +{ + // Initialize menu data + MainMenuData menudata; + menudata.address = address; + menudata.name = playername; + menudata.port = itos(game_params.socket_port); + menudata.errormessage = wide_to_narrow(*error_message); + + *error_message = L""; + + if (cmd_args.exists("password")) + menudata.password = cmd_args.get("password"); + + menudata.enable_public = g_settings->getBool("server_announce"); + + // If a world was commanded, append and select it + if (game_params.world_path != "") { + worldspec.gameid = getWorldGameId(game_params.world_path, true); + worldspec.name = _("[--world parameter]"); + + if (worldspec.gameid == "") { // Create new + worldspec.gameid = g_settings->get("default_game"); + worldspec.name += " [new]"; + } + worldspec.path = game_params.world_path; + } + + /* Show the GUI menu + */ + if (!skip_main_menu) { + main_menu(&menudata); + + // Skip further loading if there was an exit signal. + if (*porting::signal_handler_killstatus()) + return false; + + address = menudata.address; + int newport = stoi(menudata.port); + if (newport != 0) + game_params.socket_port = newport; + + simple_singleplayer_mode = menudata.simple_singleplayer_mode; + + std::vector<WorldSpec> worldspecs = getAvailableWorlds(); + + if (menudata.selected_world >= 0 + && menudata.selected_world < (int)worldspecs.size()) { + g_settings->set("selected_world_path", + worldspecs[menudata.selected_world].path); + worldspec = worldspecs[menudata.selected_world]; + } + } + + if (menudata.errormessage != "") { + /* The calling function will pass this back into this function upon the + * next iteration (if any) causing it to be displayed by the GUI + */ + *error_message = narrow_to_wide(menudata.errormessage); + return false; + } + + if (menudata.name == "") + menudata.name = std::string("Guest") + itos(myrand_range(1000, 9999)); + else + playername = menudata.name; + + password = translatePassword(playername, narrow_to_wide(menudata.password)); + + g_settings->set("name", playername); + + current_playername = playername; + current_password = password; + current_address = address; + current_port = game_params.socket_port; + + // If using simple singleplayer mode, override + if (simple_singleplayer_mode) { + assert(skip_main_menu == false); + current_playername = "singleplayer"; + current_password = ""; + current_address = ""; + current_port = myrand_range(49152, 65535); + } else if (address != "") { + ServerListSpec server; + server["name"] = menudata.servername; + server["address"] = menudata.address; + server["port"] = menudata.port; + server["description"] = menudata.serverdescription; + ServerList::insert(server); + } + + infostream << "Selected world: " << worldspec.name + << " [" << worldspec.path << "]" << std::endl; + + if (current_address == "") { // If local game + if (worldspec.path == "") { + *error_message = wgettext("No world selected and no address " + "provided. Nothing to do."); + errorstream << wide_to_narrow(*error_message) << std::endl; + return false; + } + + if (!fs::PathExists(worldspec.path)) { + *error_message = wgettext("Provided world path doesn't exist: ") + + narrow_to_wide(worldspec.path); + errorstream << wide_to_narrow(*error_message) << std::endl; + return false; + } + + // Load gamespec for required game + gamespec = findWorldSubgame(worldspec.path); + if (!gamespec.isValid() && !game_params.game_spec.isValid()) { + *error_message = wgettext("Could not find or load game \"") + + narrow_to_wide(worldspec.gameid) + L"\""; + errorstream << wide_to_narrow(*error_message) << std::endl; + return false; + } + + if (porting::signal_handler_killstatus()) + return true; + + if (game_params.game_spec.isValid() && + game_params.game_spec.id != worldspec.gameid) { + errorstream << "WARNING: Overriding gamespec from \"" + << worldspec.gameid << "\" to \"" + << game_params.game_spec.id << "\"" << std::endl; + gamespec = game_params.game_spec; + } + + if (!gamespec.isValid()) { + *error_message = wgettext("Invalid gamespec."); + *error_message += L" (world_gameid=" + + narrow_to_wide(worldspec.gameid) + L")"; + errorstream << wide_to_narrow(*error_message) << std::endl; + return false; + } + } + + return true; +} + +void ClientLauncher::main_menu(MainMenuData *menudata) +{ + bool *kill = porting::signal_handler_killstatus(); + video::IVideoDriver *driver = device->getVideoDriver(); + + infostream << "Waiting for other menus" << std::endl; + while (device->run() && *kill == false) { + if (noMenuActive()) + break; + driver->beginScene(true, true, video::SColor(255, 128, 128, 128)); + guienv->drawAll(); + driver->endScene(); + // On some computers framerate doesn't seem to be automatically limited + sleep_ms(25); + } + infostream << "Waited for other menus" << std::endl; + + // Cursor can be non-visible when coming from the game +#ifndef ANDROID + device->getCursorControl()->setVisible(true); +#endif + + /* show main menu */ + GUIEngine mymenu(device, guiroot, &g_menumgr, smgr, menudata, *kill); + + smgr->clear(); /* leave scene manager in a clean state */ +} + +bool ClientLauncher::create_engine_device(int log_level) +{ + static const irr::ELOG_LEVEL irr_log_level[5] = { + ELL_NONE, + ELL_ERROR, + ELL_WARNING, + ELL_INFORMATION, +#if (IRRLICHT_VERSION_MAJOR == 1 && IRRLICHT_VERSION_MINOR < 8) + ELL_INFORMATION +#else + ELL_DEBUG +#endif + }; + + // Resolution selection + bool fullscreen = g_settings->getBool("fullscreen"); + u16 screenW = g_settings->getU16("screenW"); + u16 screenH = g_settings->getU16("screenH"); + + // bpp, fsaa, vsync + bool vsync = g_settings->getBool("vsync"); + u16 bits = g_settings->getU16("fullscreen_bpp"); + u16 fsaa = g_settings->getU16("fsaa"); + + // Determine driver + video::E_DRIVER_TYPE driverType = video::EDT_OPENGL; + std::string driverstring = g_settings->get("video_driver"); + std::vector<video::E_DRIVER_TYPE> drivers + = porting::getSupportedVideoDrivers(); + u32 i; + for (i = 0; i != drivers.size(); i++) { + if (!strcasecmp(driverstring.c_str(), + porting::getVideoDriverName(drivers[i]))) { + driverType = drivers[i]; + break; + } + } + if (i == drivers.size()) { + errorstream << "Invalid video_driver specified; " + "defaulting to opengl" << std::endl; + } + + SIrrlichtCreationParameters params = SIrrlichtCreationParameters(); + params.DriverType = driverType; + params.WindowSize = core::dimension2d<u32>(screenW, screenH); + params.Bits = bits; + params.AntiAlias = fsaa; + params.Fullscreen = fullscreen; + params.Stencilbuffer = false; + params.Vsync = vsync; + params.EventReceiver = receiver; + params.HighPrecisionFPU = g_settings->getBool("high_precision_fpu"); +#ifdef __ANDROID__ + params.PrivateData = porting::app_global; + params.OGLES2ShaderPath = std::string(porting::path_user + DIR_DELIM + + "media" + DIR_DELIM + "Shaders" + DIR_DELIM).c_str(); +#endif + + device = createDeviceEx(params); + + if (device) { + // Map our log level to irrlicht engine one. + ILogger* irr_logger = device->getLogger(); + irr_logger->setLogLevel(irr_log_level[log_level]); + + porting::initIrrlicht(device); + } + + return device != NULL; +} + +void ClientLauncher::speed_tests() +{ + // volatile to avoid some potential compiler optimisations + volatile static s16 temp16; + volatile static f32 tempf; + static v3f tempv3f1; + static v3f tempv3f2; + static std::string tempstring; + static std::string tempstring2; + + tempv3f1 = v3f(); + tempv3f2 = v3f(); + tempstring = std::string(); + tempstring2 = std::string(); + + { + infostream << "The following test should take around 20ms." << std::endl; + TimeTaker timer("Testing std::string speed"); + const u32 jj = 10000; + for (u32 j = 0; j < jj; j++) { + tempstring = ""; + tempstring2 = ""; + const u32 ii = 10; + for (u32 i = 0; i < ii; i++) { + tempstring2 += "asd"; + } + for (u32 i = 0; i < ii+1; i++) { + tempstring += "asd"; + if (tempstring == tempstring2) + break; + } + } + } + + infostream << "All of the following tests should take around 100ms each." + << std::endl; + + { + TimeTaker timer("Testing floating-point conversion speed"); + tempf = 0.001; + for (u32 i = 0; i < 4000000; i++) { + temp16 += tempf; + tempf += 0.001; + } + } + + { + TimeTaker timer("Testing floating-point vector speed"); + + tempv3f1 = v3f(1, 2, 3); + tempv3f2 = v3f(4, 5, 6); + for (u32 i = 0; i < 10000000; i++) { + tempf += tempv3f1.dotProduct(tempv3f2); + tempv3f2 += v3f(7, 8, 9); + } + } + + { + TimeTaker timer("Testing std::map speed"); + + std::map<v2s16, f32> map1; + tempf = -324; + const s16 ii = 300; + for (s16 y = 0; y < ii; y++) { + for (s16 x = 0; x < ii; x++) { + map1[v2s16(x, y)] = tempf; + tempf += 1; + } + } + for (s16 y = ii - 1; y >= 0; y--) { + for (s16 x = 0; x < ii; x++) { + tempf = map1[v2s16(x, y)]; + } + } + } + + { + infostream << "Around 5000/ms should do well here." << std::endl; + TimeTaker timer("Testing mutex speed"); + + JMutex m; + u32 n = 0; + u32 i = 0; + do { + n += 10000; + for (; i < n; i++) { + m.Lock(); + m.Unlock(); + } + } + // Do at least 10ms + while(timer.getTimerTime() < 10); + + u32 dtime = timer.stop(); + u32 per_ms = n / dtime; + infostream << "Done. " << dtime << "ms, " << per_ms << "/ms" << std::endl; + } +} + +bool ClientLauncher::print_video_modes() +{ + IrrlichtDevice *nulldevice; + + bool vsync = g_settings->getBool("vsync"); + u16 fsaa = g_settings->getU16("fsaa"); + MyEventReceiver* receiver = new MyEventReceiver(); + + SIrrlichtCreationParameters params = SIrrlichtCreationParameters(); + params.DriverType = video::EDT_NULL; + params.WindowSize = core::dimension2d<u32>(640, 480); + params.Bits = 24; + params.AntiAlias = fsaa; + params.Fullscreen = false; + params.Stencilbuffer = false; + params.Vsync = vsync; + params.EventReceiver = receiver; + params.HighPrecisionFPU = g_settings->getBool("high_precision_fpu"); + + nulldevice = createDeviceEx(params); + + if (nulldevice == NULL) { + delete receiver; + return false; + } + + dstream << _("Available video modes (WxHxD):") << std::endl; + + video::IVideoModeList *videomode_list = nulldevice->getVideoModeList(); + + if (videomode_list != NULL) { + s32 videomode_count = videomode_list->getVideoModeCount(); + core::dimension2d<u32> videomode_res; + s32 videomode_depth; + for (s32 i = 0; i < videomode_count; ++i) { + videomode_res = videomode_list->getVideoModeResolution(i); + videomode_depth = videomode_list->getVideoModeDepth(i); + dstream << videomode_res.Width << "x" << videomode_res.Height + << "x" << videomode_depth << std::endl; + } + + dstream << _("Active video mode (WxHxD):") << std::endl; + videomode_res = videomode_list->getDesktopResolution(); + videomode_depth = videomode_list->getDesktopDepth(); + dstream << videomode_res.Width << "x" << videomode_res.Height + << "x" << videomode_depth << std::endl; + + } + + nulldevice->drop(); + delete receiver; + + return videomode_list != NULL; +} diff --git a/src/client/clientlauncher.h b/src/client/clientlauncher.h new file mode 100644 index 000000000..c3e0ae866 --- /dev/null +++ b/src/client/clientlauncher.h @@ -0,0 +1,129 @@ +/* +Minetest +Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com> + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation; either version 2.1 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public License along +with this program; if not, write to the Free Software Foundation, Inc., +51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#ifndef __CLIENT_LAUNCHER_H__ +#define __CLIENT_LAUNCHER_H__ + +#include "irrlichttypes_extrabloated.h" +#include "client/inputhandler.h" +#include "gameparams.h" + +// A small helper class +class TimeGetter +{ +public: + virtual u32 getTime(TimePrecision prec) = 0; +}; + +// A precise irrlicht one +class IrrlichtTimeGetter: public TimeGetter +{ +public: + IrrlichtTimeGetter(IrrlichtDevice *device): + m_device(device) + {} + u32 getTime(TimePrecision prec) + { + if (prec == PRECISION_MILLI) { + if (m_device == NULL) + return 0; + return m_device->getTimer()->getRealTime(); + } else { + return porting::getTime(prec); + } + } +private: + IrrlichtDevice *m_device; +}; +// Not so precise one which works without irrlicht +class SimpleTimeGetter: public TimeGetter +{ +public: + u32 getTime(TimePrecision prec) + { + return porting::getTime(prec); + } +}; + +class ClientLauncher +{ +public: + ClientLauncher() : + list_video_modes(false), + skip_main_menu(false), + use_freetype(false), + random_input(false), + address(""), + playername(""), + password(""), + device(NULL), + input(NULL), + receiver(NULL), + skin(NULL), + font(NULL), + simple_singleplayer_mode(false), + current_playername("invĀ£lid"), + current_password(""), + current_address("does-not-exist"), + current_port(0) + {} + + ~ClientLauncher(); + + bool run(GameParams &game_params, const Settings &cmd_args); + +protected: + void init_args(GameParams &game_params, const Settings &cmd_args); + bool init_engine(int log_level); + + bool launch_game(std::wstring *error_message, GameParams &game_params, + const Settings &cmd_args); + + void main_menu(MainMenuData *menudata); + bool create_engine_device(int log_level); + + void speed_tests(); + bool print_video_modes(); + + bool list_video_modes; + bool skip_main_menu; + bool use_freetype; + bool random_input; + std::string address; + std::string playername; + std::string password; + IrrlichtDevice *device; + InputHandler *input; + MyEventReceiver *receiver; + gui::IGUISkin *skin; + gui::IGUIFont *font; + scene::ISceneManager *smgr; + SubgameSpec gamespec; + WorldSpec worldspec; + bool simple_singleplayer_mode; + + // These are set up based on the menu and other things + // TODO: Are these required since there's already playername, password, etc + std::string current_playername; + std::string current_password; + std::string current_address; + int current_port; +}; + +#endif diff --git a/src/client/inputhandler.h b/src/client/inputhandler.h new file mode 100644 index 000000000..7cd3ddc71 --- /dev/null +++ b/src/client/inputhandler.h @@ -0,0 +1,428 @@ +/* +Minetest +Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com> + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation; either version 2.1 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public License along +with this program; if not, write to the Free Software Foundation, Inc., +51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#ifndef __INPUT_HANDLER_H__ +#define __INPUT_HANDLER_H__ + +#include "irrlichttypes_extrabloated.h" + +class MyEventReceiver : public IEventReceiver +{ +public: + // This is the one method that we have to implement + virtual bool OnEvent(const SEvent& event) + { + /* + React to nothing here if a menu is active + */ + if (noMenuActive() == false) { +#ifdef HAVE_TOUCHSCREENGUI + if (m_touchscreengui != 0) { + m_touchscreengui->Toggle(false); + } +#endif + return g_menumgr.preprocessEvent(event); + } + + // Remember whether each key is down or up + if (event.EventType == irr::EET_KEY_INPUT_EVENT) { + if (event.KeyInput.PressedDown) { + keyIsDown.set(event.KeyInput); + keyWasDown.set(event.KeyInput); + } else { + keyIsDown.unset(event.KeyInput); + } + } + +#ifdef HAVE_TOUCHSCREENGUI + // case of touchscreengui we have to handle different events + if ((m_touchscreengui != 0) && + (event.EventType == irr::EET_TOUCH_INPUT_EVENT)) { + m_touchscreengui->translateEvent(event); + return true; + } +#endif + // handle mouse events + if (event.EventType == irr::EET_MOUSE_INPUT_EVENT) { + if (noMenuActive() == false) { + left_active = false; + middle_active = false; + right_active = false; + } else { + left_active = event.MouseInput.isLeftPressed(); + middle_active = event.MouseInput.isMiddlePressed(); + right_active = event.MouseInput.isRightPressed(); + + if (event.MouseInput.Event == EMIE_LMOUSE_PRESSED_DOWN) { + leftclicked = true; + } + if (event.MouseInput.Event == EMIE_RMOUSE_PRESSED_DOWN) { + rightclicked = true; + } + if (event.MouseInput.Event == EMIE_LMOUSE_LEFT_UP) { + leftreleased = true; + } + if (event.MouseInput.Event == EMIE_RMOUSE_LEFT_UP) { + rightreleased = true; + } + if (event.MouseInput.Event == EMIE_MOUSE_WHEEL) { + mouse_wheel += event.MouseInput.Wheel; + } + } + } + if (event.EventType == irr::EET_LOG_TEXT_EVENT) { + dstream << std::string("Irrlicht log: ") + std::string(event.LogEvent.Text) + << std::endl; + return true; + } + /* always return false in order to continue processing events */ + return false; + } + + bool IsKeyDown(const KeyPress &keyCode) const + { + return keyIsDown[keyCode]; + } + + // Checks whether a key was down and resets the state + bool WasKeyDown(const KeyPress &keyCode) + { + bool b = keyWasDown[keyCode]; + if (b) + keyWasDown.unset(keyCode); + return b; + } + + s32 getMouseWheel() + { + s32 a = mouse_wheel; + mouse_wheel = 0; + return a; + } + + void clearInput() + { + keyIsDown.clear(); + keyWasDown.clear(); + + leftclicked = false; + rightclicked = false; + leftreleased = false; + rightreleased = false; + + left_active = false; + middle_active = false; + right_active = false; + + mouse_wheel = 0; + } + + MyEventReceiver() + { + clearInput(); +#ifdef HAVE_TOUCHSCREENGUI + m_touchscreengui = NULL; +#endif + } + + bool leftclicked; + bool rightclicked; + bool leftreleased; + bool rightreleased; + + bool left_active; + bool middle_active; + bool right_active; + + s32 mouse_wheel; + +#ifdef HAVE_TOUCHSCREENGUI + TouchScreenGUI* m_touchscreengui; +#endif + +private: + // The current state of keys + KeyList keyIsDown; + // Whether a key has been pressed or not + KeyList keyWasDown; +}; + + +/* + Separated input handler +*/ + +class RealInputHandler : public InputHandler +{ +public: + RealInputHandler(IrrlichtDevice *device, MyEventReceiver *receiver): + m_device(device), + m_receiver(receiver), + m_mousepos(0,0) + { + } + virtual bool isKeyDown(const KeyPress &keyCode) + { + return m_receiver->IsKeyDown(keyCode); + } + virtual bool wasKeyDown(const KeyPress &keyCode) + { + return m_receiver->WasKeyDown(keyCode); + } + virtual v2s32 getMousePos() + { + if (m_device->getCursorControl()) { + return m_device->getCursorControl()->getPosition(); + } + else { + return m_mousepos; + } + } + virtual void setMousePos(s32 x, s32 y) + { + if (m_device->getCursorControl()) { + m_device->getCursorControl()->setPosition(x, y); + } + else { + m_mousepos = v2s32(x,y); + } + } + + virtual bool getLeftState() + { + return m_receiver->left_active; + } + virtual bool getRightState() + { + return m_receiver->right_active; + } + + virtual bool getLeftClicked() + { + return m_receiver->leftclicked; + } + virtual bool getRightClicked() + { + return m_receiver->rightclicked; + } + virtual void resetLeftClicked() + { + m_receiver->leftclicked = false; + } + virtual void resetRightClicked() + { + m_receiver->rightclicked = false; + } + + virtual bool getLeftReleased() + { + return m_receiver->leftreleased; + } + virtual bool getRightReleased() + { + return m_receiver->rightreleased; + } + virtual void resetLeftReleased() + { + m_receiver->leftreleased = false; + } + virtual void resetRightReleased() + { + m_receiver->rightreleased = false; + } + + virtual s32 getMouseWheel() + { + return m_receiver->getMouseWheel(); + } + + void clear() + { + m_receiver->clearInput(); + } +private: + IrrlichtDevice *m_device; + MyEventReceiver *m_receiver; + v2s32 m_mousepos; +}; + +class RandomInputHandler : public InputHandler +{ +public: + RandomInputHandler() + { + leftdown = false; + rightdown = false; + leftclicked = false; + rightclicked = false; + leftreleased = false; + rightreleased = false; + keydown.clear(); + } + virtual bool isKeyDown(const KeyPress &keyCode) + { + return keydown[keyCode]; + } + virtual bool wasKeyDown(const KeyPress &keyCode) + { + return false; + } + virtual v2s32 getMousePos() + { + return mousepos; + } + virtual void setMousePos(s32 x, s32 y) + { + mousepos = v2s32(x, y); + } + + virtual bool getLeftState() + { + return leftdown; + } + virtual bool getRightState() + { + return rightdown; + } + + virtual bool getLeftClicked() + { + return leftclicked; + } + virtual bool getRightClicked() + { + return rightclicked; + } + virtual void resetLeftClicked() + { + leftclicked = false; + } + virtual void resetRightClicked() + { + rightclicked = false; + } + + virtual bool getLeftReleased() + { + return leftreleased; + } + virtual bool getRightReleased() + { + return rightreleased; + } + virtual void resetLeftReleased() + { + leftreleased = false; + } + virtual void resetRightReleased() + { + rightreleased = false; + } + + virtual s32 getMouseWheel() + { + return 0; + } + + virtual void step(float dtime) + { + { + static float counter1 = 0; + counter1 -= dtime; + if (counter1 < 0.0) { + counter1 = 0.1 * Rand(1, 40); + keydown.toggle(getKeySetting("keymap_jump")); + } + } + { + static float counter1 = 0; + counter1 -= dtime; + if (counter1 < 0.0) { + counter1 = 0.1 * Rand(1, 40); + keydown.toggle(getKeySetting("keymap_special1")); + } + } + { + static float counter1 = 0; + counter1 -= dtime; + if (counter1 < 0.0) { + counter1 = 0.1 * Rand(1, 40); + keydown.toggle(getKeySetting("keymap_forward")); + } + } + { + static float counter1 = 0; + counter1 -= dtime; + if (counter1 < 0.0) { + counter1 = 0.1 * Rand(1, 40); + keydown.toggle(getKeySetting("keymap_left")); + } + } + { + static float counter1 = 0; + counter1 -= dtime; + if (counter1 < 0.0) { + counter1 = 0.1 * Rand(1, 20); + mousespeed = v2s32(Rand(-20, 20), Rand(-15, 20)); + } + } + { + static float counter1 = 0; + counter1 -= dtime; + if (counter1 < 0.0) { + counter1 = 0.1 * Rand(1, 30); + leftdown = !leftdown; + if (leftdown) + leftclicked = true; + if (!leftdown) + leftreleased = true; + } + } + { + static float counter1 = 0; + counter1 -= dtime; + if (counter1 < 0.0) { + counter1 = 0.1 * Rand(1, 15); + rightdown = !rightdown; + if (rightdown) + rightclicked = true; + if (!rightdown) + rightreleased = true; + } + } + mousepos += mousespeed; + } + + s32 Rand(s32 min, s32 max) + { + return (myrand()%(max-min+1))+min; + } +private: + KeyList keydown; + v2s32 mousepos; + v2s32 mousespeed; + bool leftdown; + bool rightdown; + bool leftclicked; + bool rightclicked; + bool leftreleased; + bool rightreleased; +}; + +#endif |