From 3eeae12c498d1a4dbe969462d2ba841f77ee3ccb Mon Sep 17 00:00:00 2001 From: Andrei Karas Date: Sun, 2 Jan 2011 01:48:38 +0200 Subject: Initial commit. This code based on mana client http://www.gitorious.org/mana/mana and my private repository. --- src/client.cpp | 1986 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1986 insertions(+) create mode 100644 src/client.cpp (limited to 'src/client.cpp') diff --git a/src/client.cpp b/src/client.cpp new file mode 100644 index 000000000..0039ce025 --- /dev/null +++ b/src/client.cpp @@ -0,0 +1,1986 @@ +/* + * The Mana Client + * Copyright (C) 2004-2009 The Mana World Development Team + * Copyright (C) 2009-2010 The Mana Developers + * + * This file is part of The Mana Client. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include "client.h" +#include "main.h" + +#include "chatlog.h" +#include "configuration.h" +#include "emoteshortcut.h" +#include "event.h" +#include "game.h" +#include "itemshortcut.h" +#include "dropshortcut.h" +#include "keyboardconfig.h" +#ifdef USE_OPENGL +#include "openglgraphics.h" +#include "opengl1graphics.h" +#endif +#include "playerrelations.h" +#include "sound.h" +#include "statuseffect.h" +#include "units.h" + +#include "gui/changeemaildialog.h" +#include "gui/changepassworddialog.h" +#include "gui/charselectdialog.h" +#include "gui/connectiondialog.h" +#include "gui/gui.h" +#include "gui/login.h" +#include "gui/okdialog.h" +#include "gui/quitdialog.h" +#include "gui/register.h" +#include "gui/sdlinput.h" +#include "gui/serverdialog.h" +#include "gui/setup.h" +#include "gui/theme.h" +#include "gui/unregisterdialog.h" +#include "gui/updatewindow.h" +#include "gui/userpalette.h" +#include "gui/worldselectdialog.h" + +#include "gui/widgets/button.h" +#include "gui/widgets/chattab.h" +#include "gui/widgets/desktop.h" + +#include "net/charhandler.h" +#include "net/gamehandler.h" +#include "net/generalhandler.h" +#include "net/logindata.h" +#include "net/loginhandler.h" +#include "net/net.h" +#include "net/packetcounters.h" +#include "net/worldinfo.h" + +#include "resources/colordb.h" +#include "resources/emotedb.h" +#include "resources/image.h" +#include "resources/itemdb.h" +#include "resources/monsterdb.h" +#include "resources/specialdb.h" +#include "resources/npcdb.h" +#include "resources/resourcemanager.h" + +#include "utils/gettext.h" +#include "utils/mkdir.h" +#include "utils/stringutils.h" + +#ifdef __APPLE__ +#include +#endif + +#include +#include + +#ifdef WIN32 +#include +#include "utils/specialfolder.h" +#else +#include +#endif + +#include +#include + +#include +#include + +#include "mumblemanager.h" + +/** + * Tells the max tick value, + * setting it back to zero (and start again). + */ +static const int MAX_TICK_VALUE = 10000; + +static const int defaultSfxVolume = 100; +static const int defaultMusicVolume = 60; + +// TODO: Get rid fo these globals +std::string errorMessage; +ErrorListener errorListener; +LoginData loginData; + +Configuration config; /**< XML file configuration reader */ +Configuration serverConfig; /**< XML file server configuration reader */ +Configuration branding; /**< XML branding information reader */ +Configuration paths; /**< XML default paths information reader */ +Logger *logger; /**< Log object */ +ChatLogger *chatLogger; /**< Chat log object */ +KeyboardConfig keyboard; +UserPalette *userPalette; +Graphics *graphics; + +Sound sound; + +Uint32 nextTick(Uint32 interval, void *param _UNUSED_); +Uint32 nextSecond(Uint32 interval, void *param _UNUSED_); + +void ErrorListener::action(const gcn::ActionEvent &) +{ + Client::setState(STATE_CHOOSE_SERVER); +} + +volatile int tick_time; /**< Tick counter */ +volatile int fps = 0; /**< Frames counted in the last second */ +volatile int frame_count = 0; /**< Counts the frames during one second */ +volatile int cur_time; +volatile bool runCounters; +bool isSafeMode = false; + +/** + * Advances game logic counter. + * Called every 10 milliseconds by SDL_AddTimer() + * @see MILLISECONDS_IN_A_TICK value + */ +Uint32 nextTick(Uint32 interval, void *param _UNUSED_) +{ + tick_time++; + if (tick_time == MAX_TICK_VALUE) + tick_time = 0; + return interval; +} + +/** + * Updates fps. + * Called every seconds by SDL_AddTimer() + */ +Uint32 nextSecond(Uint32 interval, void *param _UNUSED_) +{ + fps = frame_count; + frame_count = 0; + + return interval; +} + +/** + * @return the elapsed time in milliseconds + * between two tick values. + */ +int get_elapsed_time(int start_time) +{ + if (start_time <= tick_time) + { + return (tick_time - start_time) * MILLISECONDS_IN_A_TICK; + } + else + { + return (tick_time + (MAX_TICK_VALUE - start_time)) + * MILLISECONDS_IN_A_TICK; + } +} + + +// This anonymous namespace hides whatever is inside from other modules. +namespace +{ + +class AccountListener : public gcn::ActionListener +{ + public: + void action(const gcn::ActionEvent &) + { + Client::setState(STATE_CHAR_SELECT); + } +} accountListener; + +class LoginListener : public gcn::ActionListener +{ + public: + void action(const gcn::ActionEvent &) + { + Client::setState(STATE_LOGIN); + } +} loginListener; + +} // anonymous namespace + + +Client *Client::mInstance = 0; + +Client::Client(const Options &options): + mOptions(options), + mServerConfigDir(""), + mRootDir(""), + mCurrentDialog(0), + mQuitDialog(0), + mDesktop(0), + mSetupButton(0), + mState(STATE_CHOOSE_SERVER), + mOldState(STATE_START), + mIcon(0), + mLogicCounterId(0), + mSecondsCounterId(0), + mLimitFps(false), + mConfigAutoSaved(false), + mIsMinimized(false), + mGuiAlpha(1.0f) +{ + assert(!mInstance); + mInstance = this; + + logger = new Logger; + + // Load branding information + if (!options.brandingPath.empty()) + branding.init(options.brandingPath); + branding.setDefaultValues(getBrandingDefaults()); + + initRootDir(); + initHomeDir(); + + // Configure logger + if (!options.logFileName.empty()) + logger->setLogFile(options.logFileName); + else + logger->setLogFile(mLocalDataDir + std::string("/manaplus.log")); + + initConfiguration(); + logger->setDebugLog(config.getBoolValue("debugLog")); + + storeSafeParameters(); + + chatLogger = new ChatLogger; + if (options.chatLogDir == "") + chatLogger->setLogDir(mLocalDataDir + std::string("/logs/")); + else + chatLogger->setLogDir(options.chatLogDir); + + logger->setLogToStandardOut(config.getBoolValue("logToStandardOut")); + + // Log the mana version + logger->log("ManaPlus %s", FULL_VERSION); + logger->log("Start configPath: " + config.getConfigPath()); + + initScreenshotDir(); + + // Initialize SDL + logger->log1("Initializing SDL..."); + if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER) < 0) + { + logger->error(strprintf("Could not initialize SDL: %s", + SDL_GetError())); + } + atexit(SDL_Quit); + + initPacketLimiter(); + SDL_EnableUNICODE(1); + SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL); + + SDL_WM_SetCaption(branding.getValue("appName", "ManaPlus").c_str(), NULL); + + ResourceManager *resman = ResourceManager::getInstance(); + + if (!resman->setWriteDir(mLocalDataDir)) + { + logger->error(strprintf("%s couldn't be set as home directory! " + "Exiting.", mLocalDataDir.c_str())); + } + +#if defined USE_OPENGL + Image::SDLSetEnableAlphaCache(config.getBoolValue("alphaCache") + && !config.getIntValue("opengl")); + Image::setEnableAlpha(config.getFloatValue("guialpha") != 1.0f + || config.getIntValue("opengl")); +#else + Image::SDLSetEnableAlphaCache(config.getBoolValue("alphaCache")); + Image::setEnableAlpha(config.getFloatValue("guialpha") != 1.0f); +#endif + +#if defined __APPLE__ + CFBundleRef mainBundle = CFBundleGetMainBundle(); + CFURLRef resourcesURL = CFBundleCopyResourcesDirectoryURL(mainBundle); + char path[PATH_MAX]; + if (!CFURLGetFileSystemRepresentation(resourcesURL, TRUE, (UInt8 *)path, + PATH_MAX)) + { + fprintf(stderr, "Can't find Resources directory\n"); + } + CFRelease(resourcesURL); + //possible crash + strncat(path, "/data", PATH_MAX - 1); + resman->addToSearchPath(path, false); + mPackageDir = path; +#else + resman->addToSearchPath(PKG_DATADIR "data", false); + mPackageDir = PKG_DATADIR "data"; +#endif + + resman->addToSearchPath("data", false); + + // Add branding/data to PhysFS search path + if (!options.brandingPath.empty()) + { + std::string path = options.brandingPath; + + // Strip blah.mana from the path +#ifdef WIN32 + int loc1 = path.find_last_of('/'); + int loc2 = path.find_last_of('\\'); + int loc = static_cast(std::max(loc1, loc2)); +#else + int loc = static_cast(path.find_last_of('/')); +#endif + if (loc > 0) + resman->addToSearchPath(path.substr(0, loc + 1) + "data", false); + } + + // Add the main data directories to our PhysicsFS search path + if (!options.dataPath.empty()) + resman->addToSearchPath(options.dataPath, false); + + // Add the local data directory to PhysicsFS search path + resman->addToSearchPath(mLocalDataDir, false); + + //resman->selectSkin(); + +#ifdef WIN32 + static SDL_SysWMinfo pInfo; + SDL_GetWMInfo(&pInfo); + HICON icon = LoadIcon(GetModuleHandle(NULL), "A"); + if (icon) + SetClassLong(pInfo.window, GCL_HICON, (LONG) icon); +#else + mIcon = IMG_Load(resman->getPath( + branding.getValue("appIcon", "icons/manaplus.png")).c_str()); + if (mIcon) + { + SDL_SetAlpha(mIcon, SDL_SRCALPHA, SDL_ALPHA_OPAQUE); + SDL_WM_SetIcon(mIcon, NULL); + } +#endif + +#ifdef USE_OPENGL + int useOpenGL = 0; + if (!mOptions.noOpenGL) + useOpenGL = config.getIntValue("opengl"); + + // Setup image loading for the right image format + Image::setLoadAsOpenGL(useOpenGL); + + // Create the graphics context + switch(useOpenGL) + { + case 0: + graphics = new Graphics; + break; + case 1: + default: + graphics = new OpenGLGraphics; + break; + case 2: + graphics = new OpenGL1Graphics; + break; + }; + +#else + // Create the graphics context + graphics = new Graphics; +#endif + + runCounters = config.getBoolValue("packetcounters"); + + const int width = config.getIntValue("screenwidth"); + const int height = config.getIntValue("screenheight"); + const int bpp = 0; + const bool fullscreen = config.getBoolValue("screen"); + const bool hwaccel = config.getBoolValue("hwaccel"); + + // Try to set the desired video mode + if (!graphics->setVideoMode(width, height, bpp, fullscreen, hwaccel)) + { + logger->error(strprintf("Couldn't set %dx%dx%d video mode: %s", + width, height, bpp, SDL_GetError())); + } + + // Initialize for drawing + graphics->_beginDraw(); + + Theme::selectSkin(); +// Theme::prepareThemePath(); + + // Initialize the item and emote shortcuts. + for (int f = 0; f < SHORTCUT_TABS; f ++) + itemShortcut[f] = new ItemShortcut(f); + + emoteShortcut = new EmoteShortcut; + + // Initialize the drop shortcuts. + dropShortcut = new DropShortcut; + + gui = new Gui(graphics); + + // Initialize sound engine + try + { + if (config.getBoolValue("sound")) + sound.init(); + + sound.setSfxVolume(config.getIntValue("sfxVolume")); + sound.setMusicVolume(config.getIntValue("musicVolume")); + } + catch (const char *err) + { + mState = STATE_ERROR; + errorMessage = err; + logger->log("Warning: %s", err); + } + + // Initialize keyboard + keyboard.init(); + + // Initialise player relations + player_relations.init(); + + userPalette = new UserPalette; + setupWindow = new Setup; + + sound.playMusic(branding.getValue("loginMusic", "Magick - Real.ogg")); + + // Initialize default server + mCurrentServer.hostname = options.serverName; + mCurrentServer.port = options.serverPort; + + loginData.username = options.username; + loginData.password = options.password; + loginData.remember = serverConfig.getValue("remember", 0); + loginData.registerLogin = false; + + if (mCurrentServer.hostname.empty()) + { + mCurrentServer.hostname = + branding.getValue("defaultServer", "").c_str(); + } + + if (mCurrentServer.port == 0) + { + mCurrentServer.port = (short) branding.getValue("defaultPort", + DEFAULT_PORT); + mCurrentServer.type = ServerInfo::parseType( + branding.getValue("defaultServerType", "tmwathena")); + } + + if (chatLogger) + chatLogger->setServerName(mCurrentServer.hostname); + + if (loginData.username.empty() && loginData.remember) + loginData.username = serverConfig.getValue("username", ""); + + if (mState != STATE_ERROR) + mState = STATE_CHOOSE_SERVER; + + // Initialize logic and seconds counters + tick_time = 0; + mLogicCounterId = SDL_AddTimer(MILLISECONDS_IN_A_TICK, nextTick, NULL); + mSecondsCounterId = SDL_AddTimer(1000, nextSecond, NULL); + + const int fpsLimit = (int) config.getIntValue("fpslimit"); + mLimitFps = fpsLimit > 0; + + // Initialize frame limiting + mFpsManager.framecount = 0; + mFpsManager.rateticks = 0; + mFpsManager.lastticks = 0; + mFpsManager.rate = 0; + + SDL_initFramerate(&mFpsManager); + logger->log("mFpsManager.framecount: " + toString(mFpsManager.framecount)); + logger->log("mFpsManager.rateticks: " + toString(mFpsManager.rateticks)); + logger->log("mFpsManager.lastticks: " + toString(mFpsManager.lastticks)); + logger->log("mFpsManager.rate: " + toString(mFpsManager.rate)); + setFramerate(fpsLimit); + config.addListener("fpslimit", this); + config.addListener("guialpha", this); + setGuiAlpha(config.getFloatValue("guialpha")); + + optionChanged("fpslimit"); + + // Initialize PlayerInfo + PlayerInfo::init(); +} + +Client::~Client() +{ + logger->log1("Quitting1"); + config.removeListener("fpslimit", this); + config.removeListener("guialpha", this); + + SDL_RemoveTimer(mLogicCounterId); + SDL_RemoveTimer(mSecondsCounterId); + + // Unload XML databases + ColorDB::unload(); + EmoteDB::unload(); + ItemDB::unload(); + MonsterDB::unload(); + NPCDB::unload(); + StatusEffect::unload(); + + // Before config.write() since it writes the shortcuts to the config + for (int f = 0; f < SHORTCUT_TABS; f ++) + { + delete itemShortcut[f]; + itemShortcut[f] = 0; + } + delete emoteShortcut; + emoteShortcut = 0; + delete dropShortcut; + dropShortcut = 0; + + player_relations.store(); + + logger->log1("Quitting2"); + + delete gui; + gui = 0; + + logger->log1("Quitting3"); + + delete graphics; + graphics = 0; + + logger->log1("Quitting4"); + + // Shutdown libxml + xmlCleanupParser(); + + logger->log1("Quitting5"); + + // Shutdown sound + sound.close(); + + logger->log1("Quitting6"); + + ResourceManager::deleteInstance(); + + logger->log1("Quitting8"); + + SDL_FreeSurface(mIcon); + + logger->log1("Quitting9"); + + delete userPalette; + userPalette = 0; + + logger->log1("Quitting10"); + + config.write(); + serverConfig.write(); + + logger->log1("Quitting11"); + + delete chatLogger; + chatLogger = 0; + + delete logger; + logger = 0; + + mInstance = 0; +} + +int Client::exec() +{ + int lastTickTime = tick_time; + + if (!mumbleManager) + mumbleManager = new MumbleManager(); + + Game *game = 0; + SDL_Event event; + + while (mState != STATE_EXIT) + { +// bool handledEvents = false; + + if (game) + { + // Let the game handle the events while it is active + game->handleInput(); + } + else + { + // Handle SDL events + while (SDL_PollEvent(&event)) + { +// handledEvents = true; + + switch (event.type) + { + case SDL_QUIT: + mState = STATE_EXIT; + break; + + case SDL_KEYDOWN: + default: + break; + } + + guiInput->pushInput(event); + if (player_node && mumbleManager) + { + mumbleManager->setPos(player_node->getTileX(), + player_node->getTileY(), player_node->getDirection()); + } + } + } + + if (Net::getGeneralHandler()) + Net::getGeneralHandler()->flushNetwork(); + + while (get_elapsed_time(lastTickTime) > 0) + { + gui->logic(); + if (game) + game->logic(); + + ++lastTickTime; + } + + // This is done because at some point tick_time will wrap. + lastTickTime = tick_time; + + // Update the screen when application is active, delay otherwise. + if (SDL_GetAppState() & SDL_APPACTIVE) + { + frame_count++; + gui->draw(); + graphics->updateScreen(); +// logger->log("active"); + } + else + { +// logger->log("inactive"); + SDL_Delay(10); + } + + if (mLimitFps) + SDL_framerateDelay(&mFpsManager); + + // TODO: Add connect timeouts + if (mState == STATE_CONNECT_GAME && + Net::getGameHandler()->isConnected()) + { + Net::getLoginHandler()->disconnect(); + } + else if (mState == STATE_CONNECT_SERVER && + mOldState == STATE_CHOOSE_SERVER) + { + mServerName = mCurrentServer.hostname; + initServerConfig(mCurrentServer.hostname); + if (mOptions.username.empty()) + loginData.username = serverConfig.getValue("username", ""); + else + loginData.username = mOptions.username; + + loginData.remember = serverConfig.getValue("remember", 0); + + Net::connectToServer(mCurrentServer); + + if (mumbleManager) + mumbleManager->setServer(mCurrentServer.hostname); + + if (!mConfigAutoSaved) + { + mConfigAutoSaved = true; + config.write(); + } + } + else if (mState == STATE_CONNECT_SERVER && + mOldState != STATE_CHOOSE_SERVER && + Net::getLoginHandler()->isConnected()) + { + mState = STATE_LOGIN; + } + else if (mState == STATE_WORLD_SELECT && mOldState == STATE_UPDATE) + { + if (Net::getLoginHandler()->getWorlds().size() < 2) + mState = STATE_LOGIN; + } + else if (mOldState == STATE_START || + (mOldState == STATE_GAME && mState != STATE_GAME)) + { + gcn::Container *top = static_cast(gui->getTop()); + + mDesktop = new Desktop; + top->add(mDesktop); + mSetupButton = new Button(_("Setup"), "Setup", this); + mSetupButton->setPosition(top->getWidth() + - mSetupButton->getWidth() - 3, 3); + top->add(mSetupButton); + + int screenWidth = config.getIntValue("screenwidth"); + int screenHeight = config.getIntValue("screenheight"); + + mDesktop->setSize(screenWidth, screenHeight); + } + + if (mState == STATE_SWITCH_LOGIN && mOldState == STATE_GAME) + Net::getGameHandler()->disconnect(); + + if (mState != mOldState) + { + { + Mana::Event event(EVENT_STATECHANGE); + event.setInt("oldState", mOldState); + event.setInt("newState", mState); + Mana::Event::trigger(CHANNEL_CLIENT, event); + } + + if (mOldState == STATE_GAME) + { + delete game; + game = 0; + } + + mOldState = mState; + + // Get rid of the dialog of the previous state + delete mCurrentDialog; + mCurrentDialog = 0; + // State has changed, while the quitDialog was active, it might + // not be correct anymore + if (mQuitDialog) + { + mQuitDialog->scheduleDelete(); + mQuitDialog = 0; + } + + switch (mState) + { + case STATE_CHOOSE_SERVER: + logger->log1("State: CHOOSE SERVER"); + + // Allow changing this using a server choice dialog + // We show the dialog box only if the command-line + // options weren't set. + if (mOptions.serverName.empty() && mOptions.serverPort == 0 + && !branding.getValue("onlineServerList", "a").empty()) + { + // Don't allow an alpha opacity + // lower than the default value + Theme::instance()->setMinimumOpacity(0.8f); + + mCurrentDialog = new ServerDialog(&mCurrentServer, + mConfigDir); + } + else + { + mState = STATE_CONNECT_SERVER; + + // Reset options so that cancelling or connect + // timeout will show the server dialog. + mOptions.serverName.clear(); + mOptions.serverPort = 0; + } + break; + + case STATE_CONNECT_SERVER: + logger->log1("State: CONNECT SERVER"); + mCurrentDialog = new ConnectionDialog( + _("Connecting to server"), STATE_SWITCH_SERVER); + break; + + case STATE_LOGIN: + logger->log1("State: LOGIN"); + // Don't allow an alpha opacity + // lower than the default value + Theme::instance()->setMinimumOpacity(0.8f); + + loginData.updateType + = serverConfig.getValue("updateType", 1); + + if (mOptions.username.empty() + || mOptions.password.empty()) + { + mCurrentDialog = new LoginDialog(&loginData, + mCurrentServer.hostname, &mOptions.updateHost); + } + else + { + mState = STATE_LOGIN_ATTEMPT; + // Clear the password so that when login fails, the + // dialog will show up next time. + mOptions.password.clear(); + } + break; + + case STATE_LOGIN_ATTEMPT: + logger->log1("State: LOGIN ATTEMPT"); + accountLogin(&loginData); + mCurrentDialog = new ConnectionDialog( + _("Logging in"), STATE_SWITCH_SERVER); + break; + + case STATE_WORLD_SELECT: + logger->log1("State: WORLD SELECT"); + { + Worlds worlds = Net::getLoginHandler()->getWorlds(); + + if (worlds.empty()) + { + // Trust that the netcode knows what it's doing + mState = STATE_UPDATE; + } + else if (worlds.size() == 1) + { + Net::getLoginHandler()->chooseServer(0); + mState = STATE_UPDATE; + } + else + { + mCurrentDialog = new WorldSelectDialog(worlds); + if (mOptions.chooseDefault) + { + static_cast(mCurrentDialog) + ->action(gcn::ActionEvent(0, "ok")); + } + } + } + break; + + case STATE_WORLD_SELECT_ATTEMPT: + logger->log1("State: WORLD SELECT ATTEMPT"); + mCurrentDialog = new ConnectionDialog( + _("Entering game world"), STATE_WORLD_SELECT); + break; + + case STATE_UPDATE: + // Determine which source to use for the update host + if (!mOptions.updateHost.empty()) + mUpdateHost = mOptions.updateHost; + else + mUpdateHost = loginData.updateHost; + initUpdatesDir(); + + if (mOptions.skipUpdate) + { + mState = STATE_LOAD_DATA; + } + else if (loginData.updateType & LoginData::Upd_Skip) + { + UpdaterWindow::loadLocalUpdates(mLocalDataDir + "/" + + mUpdatesDir); + mState = STATE_LOAD_DATA; + } + else + { + logger->log1("State: UPDATE"); + mCurrentDialog = new UpdaterWindow(mUpdateHost, + mLocalDataDir + "/" + mUpdatesDir, + mOptions.dataPath.empty(), + loginData.updateType); + } + break; + + case STATE_LOAD_DATA: + { + logger->log1("State: LOAD DATA"); + + ResourceManager *resman = ResourceManager::getInstance(); + + // If another data path has been set, + // we don't load any other files... + if (mOptions.dataPath.empty()) + { + // Add customdata directory + resman->searchAndAddArchives( + "customdata/", + "zip", + false); + } + + if (!mOptions.skipUpdate) + { + resman->searchAndAddArchives( + mUpdatesDir + "/local/", + "zip", + false); + + resman->addToSearchPath(mLocalDataDir + "/" + + mUpdatesDir + "/local/", false); + } + + // Read default paths file 'data/paths.xml' + paths.init("paths.xml", true); + paths.setDefaultValues(getPathsDefaults()); + + Mana::Event event(EVENT_STATECHANGE); + event.setInt("newState", STATE_LOAD_DATA); + event.setInt("oldState", mOldState); + Mana::Event::trigger(CHANNEL_CLIENT, event); + + // Load XML databases + ColorDB::load(); + ItemDB::load(); + Being::load(); // Hairstyles + MonsterDB::load(); + SpecialDB::load(); + NPCDB::load(); + EmoteDB::load(); + StatusEffect::load(); + Units::loadUnits(); + + ActorSprite::load(); + + if (mDesktop) + mDesktop->reloadWallpaper(); + + mState = STATE_GET_CHARACTERS; + break; + } + case STATE_GET_CHARACTERS: + logger->log1("State: GET CHARACTERS"); + Net::getCharHandler()->requestCharacters(); + mCurrentDialog = new ConnectionDialog( + _("Requesting characters"), + STATE_SWITCH_SERVER); + break; + + case STATE_CHAR_SELECT: + logger->log1("State: CHAR SELECT"); + // Don't allow an alpha opacity + // lower than the default value + Theme::instance()->setMinimumOpacity(0.8f); + + mCurrentDialog = new CharSelectDialog(&loginData); + + if (!(static_cast(mCurrentDialog)) + ->selectByName(mOptions.character, + CharSelectDialog::Choose)) + { + (static_cast(mCurrentDialog)) + ->selectByName( + serverConfig.getValue("lastCharacter", ""), + mOptions.chooseDefault ? + CharSelectDialog::Choose : + CharSelectDialog::Focus); + } + + break; + + case STATE_CONNECT_GAME: + logger->log1("State: CONNECT GAME"); + + Net::getGameHandler()->connect(); + mCurrentDialog = new ConnectionDialog( + _("Connecting to the game server"), + Net::getNetworkType() == ServerInfo::TMWATHENA ? + STATE_CHOOSE_SERVER : STATE_SWITCH_CHARACTER); + break; + + case STATE_CHANGE_MAP: + logger->log1("State: CHANGE_MAP"); + + Net::getGameHandler()->connect(); + mCurrentDialog = new ConnectionDialog( + _("Changing game servers"), + STATE_SWITCH_CHARACTER); + break; + + case STATE_GAME: + if (player_node) + { + logger->log("Memorizing selected character %s", + player_node->getName().c_str()); + config.setValue("lastCharacter", + player_node->getName()); + if (mumbleManager) + mumbleManager->setPlayer(player_node->getName()); + } + + // Fade out logon-music here too to give the desired effect + // of "flowing" into the game. + sound.fadeOutMusic(1000); + + // Allow any alpha opacity + Theme::instance()->setMinimumOpacity(-1.0f); + + delete mSetupButton; + mSetupButton = 0; + delete mDesktop; + mDesktop = 0; + + mCurrentDialog = NULL; + + logger->log1("State: GAME"); + game = new Game; + break; + + case STATE_LOGIN_ERROR: + logger->log1("State: LOGIN ERROR"); + mCurrentDialog = new OkDialog(_("Error"), errorMessage); + mCurrentDialog->addActionListener(&loginListener); + mCurrentDialog = NULL; // OkDialog deletes itself + break; + + case STATE_ACCOUNTCHANGE_ERROR: + logger->log1("State: ACCOUNT CHANGE ERROR"); + mCurrentDialog = new OkDialog(_("Error"), errorMessage); + mCurrentDialog->addActionListener(&accountListener); + mCurrentDialog = NULL; // OkDialog deletes itself + break; + + case STATE_REGISTER_PREP: + logger->log1("State: REGISTER_PREP"); + Net::getLoginHandler()->getRegistrationDetails(); + mCurrentDialog = new ConnectionDialog( + _("Requesting registration details"), STATE_LOGIN); + break; + + case STATE_REGISTER: + logger->log1("State: REGISTER"); + mCurrentDialog = new RegisterDialog(&loginData); + break; + + case STATE_REGISTER_ATTEMPT: + logger->log("Username is %s", loginData.username.c_str()); + Net::getLoginHandler()->registerAccount(&loginData); + break; + + case STATE_CHANGEPASSWORD: + logger->log1("State: CHANGE PASSWORD"); + mCurrentDialog = new ChangePasswordDialog(&loginData); + break; + + case STATE_CHANGEPASSWORD_ATTEMPT: + logger->log1("State: CHANGE PASSWORD ATTEMPT"); + Net::getLoginHandler()->changePassword(loginData.username, + loginData.password, + loginData.newPassword); + break; + + case STATE_CHANGEPASSWORD_SUCCESS: + logger->log1("State: CHANGE PASSWORD SUCCESS"); + mCurrentDialog = new OkDialog(_("Password Change"), + _("Password changed successfully!")); + mCurrentDialog->addActionListener(&accountListener); + mCurrentDialog = NULL; // OkDialog deletes itself + loginData.password = loginData.newPassword; + loginData.newPassword = ""; + break; + + case STATE_CHANGEEMAIL: + logger->log1("State: CHANGE EMAIL"); + mCurrentDialog = new ChangeEmailDialog(&loginData); + break; + + case STATE_CHANGEEMAIL_ATTEMPT: + logger->log1("State: CHANGE EMAIL ATTEMPT"); + Net::getLoginHandler()->changeEmail(loginData.email); + break; + + case STATE_CHANGEEMAIL_SUCCESS: + logger->log1("State: CHANGE EMAIL SUCCESS"); + mCurrentDialog = new OkDialog(_("Email Change"), + _("Email changed successfully!")); + mCurrentDialog->addActionListener(&accountListener); + mCurrentDialog = NULL; // OkDialog deletes itself + break; + + case STATE_UNREGISTER: + logger->log1("State: UNREGISTER"); + mCurrentDialog = new UnRegisterDialog(&loginData); + break; + + case STATE_UNREGISTER_ATTEMPT: + logger->log1("State: UNREGISTER ATTEMPT"); + Net::getLoginHandler()->unregisterAccount( + loginData.username, loginData.password); + break; + + case STATE_UNREGISTER_SUCCESS: + logger->log1("State: UNREGISTER SUCCESS"); + Net::getLoginHandler()->disconnect(); + + mCurrentDialog = new OkDialog(_("Unregister Successful"), + _("Farewell, come back any time...")); + loginData.clear(); + //The errorlistener sets the state to STATE_CHOOSE_SERVER + mCurrentDialog->addActionListener(&errorListener); + mCurrentDialog = NULL; // OkDialog deletes itself + break; + + case STATE_SWITCH_SERVER: + logger->log1("State: SWITCH SERVER"); + + Net::getLoginHandler()->disconnect(); + Net::getGameHandler()->disconnect(); + + mState = STATE_CHOOSE_SERVER; + break; + + case STATE_SWITCH_LOGIN: + logger->log1("State: SWITCH LOGIN"); + + Net::getLoginHandler()->logout(); + + mState = STATE_LOGIN; + break; + + case STATE_SWITCH_CHARACTER: + logger->log1("State: SWITCH CHARACTER"); + + // Done with game + Net::getGameHandler()->disconnect(); + + mState = STATE_GET_CHARACTERS; + break; + + case STATE_LOGOUT_ATTEMPT: + logger->log1("State: LOGOUT ATTEMPT"); + // TODO + break; + + case STATE_WAIT: + logger->log1("State: WAIT"); + break; + + case STATE_EXIT: + logger->log1("State: EXIT"); + Net::unload(); + break; + + case STATE_FORCE_QUIT: + logger->log1("State: FORCE QUIT"); + if (Net::getGeneralHandler()) + Net::getGeneralHandler()->unload(); + mState = STATE_EXIT; + break; + + case STATE_ERROR: + logger->log1("State: ERROR"); + logger->log("Error: %s\n", errorMessage.c_str()); + mCurrentDialog = new OkDialog(_("Error"), errorMessage); + mCurrentDialog->addActionListener(&errorListener); + mCurrentDialog = NULL; // OkDialog deletes itself + Net::getGameHandler()->disconnect(); + break; + + case STATE_AUTORECONNECT_SERVER: + //++++++ + break; + + default: + mState = STATE_FORCE_QUIT; + break; + } + } + } + + return 0; +} + +void Client::optionChanged(const std::string &name) +{ + if (name == "fpslimit") + { + const int fpsLimit = config.getIntValue("fpslimit"); + mLimitFps = fpsLimit > 0; + setFramerate(fpsLimit); + } + else if (name == "guialpha") + { + setGuiAlpha(config.getFloatValue("guialpha")); + } +} + +void Client::action(const gcn::ActionEvent &event) +{ + Window *window = 0; + + if (event.getId() == "Setup") + window = setupWindow; + + if (window) + { + window->setVisible(!window->isVisible()); + if (window->isVisible()) + window->requestMoveToTop(); + } +} + +void Client::initRootDir() +{ + mRootDir = PHYSFS_getBaseDir(); + std::string portableName = mRootDir + "portable.xml"; + struct stat statbuf; + + if (!stat(portableName.c_str(), &statbuf) && S_ISREG(statbuf.st_mode)) + { + std::string dir; + Configuration portable; + portable.init(portableName); + + logger->log("Portable file: %s", portableName.c_str()); + + if (mOptions.localDataDir.empty()) + { + dir = portable.getValue("dataDir", ""); + if (!dir.empty()) + { + mOptions.localDataDir = mRootDir + dir; + logger->log("Portable data dir: %s", + mOptions.localDataDir.c_str()); + } + } + + if (mOptions.configDir.empty()) + { + dir = portable.getValue("configDir", ""); + if (!dir.empty()) + { + mOptions.configDir = mRootDir + dir; + logger->log("Portable config dir: %s", + mOptions.configDir.c_str()); + } + } + + if (mOptions.screenshotDir.empty()) + { + dir = portable.getValue("screenshotDir", ""); + if (!dir.empty()) + { + mOptions.screenshotDir = mRootDir + dir; + logger->log("Portable screenshot dir: %s", + mOptions.screenshotDir.c_str()); + } + } + } +} + +/** + * Initializes the home directory. On UNIX and FreeBSD, ~/.mana is used. On + * Windows and other systems we use the current working directory. + */ +void Client::initHomeDir() +{ + mLocalDataDir = mOptions.localDataDir; + + if (mLocalDataDir.empty()) + { +#ifdef __APPLE__ + // Use Application Directory instead of .mana + mLocalDataDir = std::string(PHYSFS_getUserDir()) + + "/Library/Application Support/" + + branding.getValue("appName", "Mana"); +#elif defined WIN32 + mLocalDataDir = getSpecialFolderLocation(CSIDL_LOCAL_APPDATA); + if (mLocalDataDir.empty()) + mLocalDataDir = std::string(PHYSFS_getUserDir()); + mLocalDataDir += "/Mana"; +#else + mLocalDataDir = std::string(PHYSFS_getUserDir()) + + ".local/share/mana"; +#endif + } + + if (mkdir_r(mLocalDataDir.c_str())) + { + logger->error(strprintf(_("%s doesn't exist and can't be created! " + "Exiting."), mLocalDataDir.c_str())); + } + + mConfigDir = mOptions.configDir; + + if (mConfigDir.empty()) + { +#ifdef __APPLE__ + mConfigDir = mLocalDataDir + "/" + + branding.getValue("appShort", "mana"); +#elif defined WIN32 + mConfigDir = getSpecialFolderLocation(CSIDL_APPDATA); + if (mConfigDir.empty()) + mConfigDir = mLocalDataDir; + else + mConfigDir += "/mana/" + branding.getValue("appShort", "Mana"); +#else + mConfigDir = std::string(PHYSFS_getUserDir()) + + "/.config/mana/" + branding.getValue("appShort", "mana"); +#endif + logger->log("Generating config dir: " + mConfigDir); + } + + if (mkdir_r(mConfigDir.c_str())) + { + logger->error(strprintf(_("%s doesn't exist and can't be created! " + "Exiting."), mConfigDir.c_str())); + } + + struct stat statbuf; + std::string newConfigFile = mConfigDir + "/config.xml"; + if (stat(newConfigFile.c_str(), &statbuf)) + { + std::string oldConfigFile = std::string(PHYSFS_getUserDir()) + + "/.mana/config.xml"; + if (mRootDir.empty() && !stat(oldConfigFile.c_str(), &statbuf) + && S_ISREG(statbuf.st_mode)) + { + std::ifstream oldConfig; + std::ofstream newConfig; + logger->log1("Copying old TMW settings."); + + oldConfig.open(oldConfigFile.c_str(), std::ios::binary); + newConfig.open(newConfigFile.c_str(), std::ios::binary); + + if (!oldConfig.is_open() || !newConfig.is_open()) + { + logger->log1("Unable to copy old settings."); + } + else + { + newConfig << oldConfig.rdbuf(); + newConfig.close(); + oldConfig.close(); + } + } + } +} + +/** + * Initializes the home directory. On UNIX and FreeBSD, ~/.mana is used. On + * Windows and other systems we use the current working directory. + */ +void Client::initServerConfig(std::string serverName) +{ + mServerConfigDir = mConfigDir + "/" + serverName; + + if (mkdir_r(mServerConfigDir.c_str())) + { + logger->error(strprintf(_("%s doesn't exist and can't be created! " + "Exiting."), mServerConfigDir.c_str())); + } + FILE *configFile = 0; + std::string configPath; + + configPath = mServerConfigDir + "/config.xml"; + configFile = fopen(configPath.c_str(), "r"); + if (!configFile) + { + configFile = fopen(configPath.c_str(), "wt"); + logger->log("Creating new server config: " + configPath); + } + if (configFile) + { + fclose(configFile); + serverConfig.init(configPath); + logger->log("serverConfigPath: " + configPath); + } + initPacketLimiter(); + initTradeFilter(); + player_relations.init(); + + // Initialize the item and emote shortcuts. + for (int f = 0; f < SHORTCUT_TABS; f ++) + { + delete itemShortcut[f]; + itemShortcut[f] = new ItemShortcut(f); + } + delete emoteShortcut; + emoteShortcut = new EmoteShortcut; + + // Initialize the drop shortcuts. + delete dropShortcut; + dropShortcut = new DropShortcut; +} + +/** + * Initialize configuration. + */ +void Client::initConfiguration() +{ + // Fill configuration with defaults + config.setValue("hwaccel", false); +#if (defined __APPLE__ || defined WIN32) && defined USE_OPENGL + config.setValue("opengl", 1); +#else + config.setValue("opengl", 0); +#endif + config.setValue("screen", false); + config.setValue("sound", true); + config.setValue("guialpha", 0.8f); + config.setValue("remember", true); + config.setValue("sfxVolume", 100); + config.setValue("musicVolume", 60); + config.setValue("fpslimit", 60); + std::string defaultUpdateHost = branding.getValue("defaultUpdateHost", ""); + config.setValue("updatehost", defaultUpdateHost); + config.setValue("customcursor", true); + config.setValue("useScreenshotDirectorySuffix", true); + config.setValue("ChatLogLength", 128); + + // Checking if the configuration file exists... otherwise create it with + // default options. + FILE *configFile = 0; + std::string configPath; +// bool oldConfig = false; +// int emptySize = config.getSize(); + + configPath = mConfigDir + "/config.xml"; + + configFile = fopen(configPath.c_str(), "r"); + + // If we can't read it, it doesn't exist ! + if (!configFile) + { + // We reopen the file in write mode and we create it + configFile = fopen(configPath.c_str(), "wt"); + logger->log1("Creating new config"); +// oldConfig = false; + } + if (!configFile) + { + logger->log("Can't create %s. Using defaults.", configPath.c_str()); + } + else + { + fclose(configFile); + config.init(configPath); + config.setDefaultValues(getConfigDefaults()); + logger->log("configPath: " + configPath); + } +} + +/** + * Parse the update host and determine the updates directory + * Then verify that the directory exists (creating if needed). + */ +void Client::initUpdatesDir() +{ + std::stringstream updates; + + // If updatesHost is currently empty, fill it from config file + if (mUpdateHost.empty()) + mUpdateHost = config.getStringValue("updatehost"); + + // Don't go out of range int he next check + if (mUpdateHost.length() < 2) + return; + + // Remove any trailing slash at the end of the update host + if (!mUpdateHost.empty() && mUpdateHost.at(mUpdateHost.size() - 1) == '/') + mUpdateHost.resize(mUpdateHost.size() - 1); + + // Parse out any "http://" or "ftp://", and set the updates directory + size_t pos; + pos = mUpdateHost.find("://"); + if (pos != mUpdateHost.npos) + { + if (pos + 3 < mUpdateHost.length() && !mUpdateHost.empty()) + { + updates << "updates/" << mUpdateHost.substr(pos + 3); + mUpdatesDir = updates.str(); + } + else + { + logger->log("Error: Invalid update host: %s", mUpdateHost.c_str()); + errorMessage = strprintf(_("Invalid update host: %s"), + mUpdateHost.c_str()); + mState = STATE_ERROR; + } + } + else + { + logger->log1("Warning: no protocol was specified for the update host"); + updates << "updates/" << mUpdateHost; + mUpdatesDir = updates.str(); + } + + ResourceManager *resman = ResourceManager::getInstance(); + + // Verify that the updates directory exists. Create if necessary. + if (!resman->isDirectory("/" + mUpdatesDir)) + { + if (!resman->mkdir("/" + mUpdatesDir)) + { +#if defined WIN32 + std::string newDir = mLocalDataDir + "\\" + mUpdatesDir; + std::string::size_type loc = newDir.find("/", 0); + + while (loc != std::string::npos) + { + newDir.replace(loc, 1, "\\"); + loc = newDir.find("/", loc); + } + + if (!CreateDirectory(newDir.c_str(), 0) && + GetLastError() != ERROR_ALREADY_EXISTS) + { + logger->log("Error: %s can't be made, but doesn't exist!", + newDir.c_str()); + errorMessage = _("Error creating updates directory!"); + mState = STATE_ERROR; + } +#else + logger->log("Error: %s/%s can't be made, but doesn't exist!", + mLocalDataDir.c_str(), mUpdatesDir.c_str()); + errorMessage = _("Error creating updates directory!"); + mState = STATE_ERROR; +#endif + } + } + std::string updateLocal = "/" + mUpdatesDir + "/local"; + std::string updateFix = "/" + mUpdatesDir + "/fix"; + if (!resman->isDirectory(updateLocal)) + resman->mkdir(updateLocal); + if (!resman->isDirectory(updateFix)) + resman->mkdir(updateFix); +} + +void Client::initScreenshotDir() +{ + if (!mOptions.screenshotDir.empty()) + { + mScreenshotDir = mOptions.screenshotDir; + if (mkdir_r(mScreenshotDir.c_str())) + { + logger->log(strprintf( + _("Error: %s doesn't exist and can't be created! " + "Exiting."), mScreenshotDir.c_str())); + } + } + else if (mScreenshotDir.empty()) + { + std::string configScreenshotDir = + config.getStringValue("screenshotDirectory"); + if (!configScreenshotDir.empty()) + { + mScreenshotDir = configScreenshotDir; + } + else + { +#ifdef WIN32 + mScreenshotDir = getSpecialFolderLocation(CSIDL_MYPICTURES); + if (mScreenshotDir.empty()) + mScreenshotDir = getSpecialFolderLocation(CSIDL_DESKTOP); +#else + mScreenshotDir = std::string(PHYSFS_getUserDir()) + "Desktop"; +#endif + } + //config.setValue("screenshotDirectory", mScreenshotDir); + logger->log("screenshotDirectory: " + mScreenshotDir); + + if (config.getBoolValue("useScreenshotDirectorySuffix")) + { + std::string configScreenshotSuffix = + branding.getValue("appShort", "Mana"); + + if (!configScreenshotSuffix.empty()) + { + mScreenshotDir += "/" + configScreenshotSuffix; +// config.setValue("screenshotDirectorySuffix", +// configScreenshotSuffix); + } + } + } +} + +void Client::accountLogin(LoginData *loginData) +{ + logger->log("Username is %s", loginData->username.c_str()); + + // Send login infos + if (loginData->registerLogin) + Net::getLoginHandler()->registerAccount(loginData); + else + Net::getLoginHandler()->loginAccount(loginData); + + // Clear the password, avoids auto login when returning to login + loginData->password = ""; + + // TODO This is not the best place to save the config, but at least better + // than the login gui window + if (loginData->remember) + serverConfig.setValue("username", loginData->username); + serverConfig.setValue("remember", loginData->remember); +} + +bool Client::copyFile(std::string &configPath, std::string &oldConfigPath) +{ + FILE *configFile = 0; + + configFile = fopen(oldConfigPath.c_str(), "r"); + + if (configFile != NULL) + { + fclose(configFile); + + std::ifstream ifs(oldConfigPath.c_str(), std::ios::binary); + std::ofstream ofs(configPath.c_str(), std::ios::binary); + ofs << ifs.rdbuf(); + ifs.close(); + ofs.close(); + return true; + } + return false; +} + +bool Client::createConfig(std::string &configPath) +{ + std::string oldHomeDir; +#ifdef __APPLE__ + // Use Application Directory instead of .mana + oldHomeDir = std::string(PHYSFS_getUserDir()) + + "/Library/Application Support/" + + branding.getValue("appName", "Mana"); +#else + oldHomeDir = std::string(PHYSFS_getUserDir()) + + "/." + branding.getValue("appShort", "mana"); +#endif + + oldHomeDir += "/config.xml"; + + logger->log("Restore config from: " + configPath); + return copyFile(configPath, oldHomeDir); +} + +void Client::storeSafeParameters() +{ + bool tmpHwaccel; + int tmpOpengl; + int tmpFpslimit; + int tmpAltFpslimit; + bool tmpSound; + int width; + int height; + std::string font; + std::string boldFont; + std::string particleFont; + std::string helpFont; + bool showBackground; + bool enableMumble; + + isSafeMode = config.getBoolValue("safemode"); + if (isSafeMode) + logger->log1("Run in safe mode"); + + tmpHwaccel = config.getBoolValue("hwaccel"); + +#if defined USE_OPENGL + tmpOpengl = config.getIntValue("opengl"); +#else + tmpOpengl = 0; +#endif + tmpFpslimit = config.getIntValue("fpslimit"); + tmpAltFpslimit = config.getIntValue("altfpslimit"); + tmpSound = config.getBoolValue("sound"); + + width = config.getIntValue("screenwidth"); + height = config.getIntValue("screenheight"); + + font = config.getStringValue("font"); + boldFont = config.getStringValue("boldFont"); + particleFont = config.getStringValue("particleFont"); + helpFont = config.getStringValue("helpFont"); + + showBackground = config.getBoolValue("showBackground"); + enableMumble = config.getBoolValue("enableMumble"); + + config.setValue("hwaccel", false); + config.setValue("opengl", 0); + config.setValue("fpslimit", 0); + config.setValue("altfpslimit", 0); + config.setValue("sound", false); + config.setValue("safemode", true); + config.setValue("screenwidth", 640); + config.setValue("screenheight", 480); + config.setValue("font", "fonts/dejavusans.ttf"); + config.setValue("boldFont", "fonts/dejavusans-bold.ttf"); + config.setValue("particleFont", "fonts/dejavusans.ttf"); + config.setValue("helpFont", "fonts/dejavusansmono.ttf"); + config.setValue("showBackground", false); + config.setValue("enableMumble", false); + + config.write(); + + if (mOptions.safeMode) + { + isSafeMode = true; + return; + } + + config.setValue("hwaccel", tmpHwaccel); + config.setValue("opengl", tmpOpengl); + config.setValue("fpslimit", tmpFpslimit); + config.setValue("altfpslimit", tmpAltFpslimit); + config.setValue("sound", tmpSound); + config.setValue("safemode", false); + config.setValue("screenwidth", width); + config.setValue("screenheight", height); + config.setValue("font", font); + config.setValue("boldFont", boldFont); + config.setValue("particleFont", particleFont); + config.setValue("helpFont", helpFont); + config.setValue("showBackground", showBackground); + config.setValue("enableMumble", enableMumble); +} + +void Client::initTradeFilter() +{ + std::string tradeListName = + Client::getServerConfigDirectory() + "/tradefilter.txt"; + + std::ofstream tradeFile; + struct stat statbuf; + + if (stat(tradeListName.c_str(), &statbuf) || !S_ISREG(statbuf.st_mode)) + { + tradeFile.open(tradeListName.c_str(), std::ios::out); + tradeFile << ": sell" << std::endl; + tradeFile << ": buy" << std::endl; + tradeFile << ": trade" << std::endl; + tradeFile << "i sell" << std::endl; + tradeFile << "i buy" << std::endl; + tradeFile << "i trade" << std::endl; + tradeFile << "i trading" << std::endl; + tradeFile << "i am buy" << std::endl; + tradeFile << "i am sell" << std::endl; + tradeFile << "i am trade" << std::endl; + tradeFile << "i am trading" << std::endl; + tradeFile << "i'm buy" << std::endl; + tradeFile << "i'm sell" << std::endl; + tradeFile << "i'm trade" << std::endl; + tradeFile << "i'm trading" << std::endl; + tradeFile.close(); + } +} + +void Client::initPacketLimiter() +{ + //here i setting packet limits. but current server is broken, + // and this limits may not help. + + mPacketLimits[PACKET_CHAT].timeLimit = 10 + 5; + mPacketLimits[PACKET_CHAT].lastTime = 0; + mPacketLimits[PACKET_CHAT].cntLimit = 1; + mPacketLimits[PACKET_CHAT].cnt = 0; + + //10 + mPacketLimits[PACKET_PICKUP].timeLimit = 10 + 5; + mPacketLimits[PACKET_PICKUP].lastTime = 0; + mPacketLimits[PACKET_PICKUP].cntLimit = 1; + mPacketLimits[PACKET_PICKUP].cnt = 0; + + //10 5 + mPacketLimits[PACKET_DROP].timeLimit = 5; + mPacketLimits[PACKET_DROP].lastTime = 0; + mPacketLimits[PACKET_DROP].cntLimit = 1; + mPacketLimits[PACKET_DROP].cnt = 0; + + //100 + mPacketLimits[PACKET_NPC_NEXT].timeLimit = 0; + mPacketLimits[PACKET_NPC_NEXT].lastTime = 0; + mPacketLimits[PACKET_NPC_NEXT].cntLimit = 1; + mPacketLimits[PACKET_NPC_NEXT].cnt = 0; + + mPacketLimits[PACKET_NPC_INPUT].timeLimit = 100; + mPacketLimits[PACKET_NPC_INPUT].lastTime = 0; + mPacketLimits[PACKET_NPC_INPUT].cntLimit = 1; + mPacketLimits[PACKET_NPC_INPUT].cnt = 0; + + //50 + mPacketLimits[PACKET_NPC_TALK].timeLimit = 60; + mPacketLimits[PACKET_NPC_TALK].lastTime = 0; + mPacketLimits[PACKET_NPC_TALK].cntLimit = 1; + mPacketLimits[PACKET_NPC_TALK].cnt = 0; + + //10 + mPacketLimits[PACKET_EMOTE].timeLimit = 10 + 5; + mPacketLimits[PACKET_EMOTE].lastTime = 0; + mPacketLimits[PACKET_EMOTE].cntLimit = 1; + mPacketLimits[PACKET_EMOTE].cnt = 0; + + //100 + mPacketLimits[PACKET_SIT].timeLimit = 100; + mPacketLimits[PACKET_SIT].lastTime = 0; + mPacketLimits[PACKET_SIT].cntLimit = 1; + mPacketLimits[PACKET_SIT].cnt = 0; + + mPacketLimits[PACKET_DIRECTION].timeLimit = 50; + mPacketLimits[PACKET_DIRECTION].lastTime = 0; + mPacketLimits[PACKET_DIRECTION].cntLimit = 1; + mPacketLimits[PACKET_DIRECTION].cnt = 0; + + //2+ + mPacketLimits[PACKET_ATTACK].timeLimit = 2 + 10; + mPacketLimits[PACKET_ATTACK].lastTime = 0; + mPacketLimits[PACKET_ATTACK].cntLimit = 1; + mPacketLimits[PACKET_ATTACK].cnt = 0; + + + if (!mServerConfigDir.empty()) + { + std::string packetLimitsName = + Client::getServerConfigDirectory() + "/packetlimiter.txt"; + + std::ifstream inPacketFile; + struct stat statbuf; + + if (stat(packetLimitsName.c_str(), &statbuf) + || !S_ISREG(statbuf.st_mode)) + { + // wtiting new file + writePacketLimits(packetLimitsName); + } + else + { // reading existent file + inPacketFile.open(packetLimitsName.c_str(), std::ios::in); + char line[101]; + + if (!inPacketFile.getline(line, 100)) + return; + + int ver = atoi(line); + + for (int f = 0; f < PACKET_SIZE; f ++) + { + if (!inPacketFile.getline(line, 100)) + break; + + if (!(ver == 1 && (f == PACKET_DROP || f == PACKET_NPC_NEXT))) + mPacketLimits[f].timeLimit = atoi(line); + } + inPacketFile.close(); + if (ver == 1) + writePacketLimits(packetLimitsName); + } + } +} + +void Client::writePacketLimits(std::string packetLimitsName) +{ + std::ofstream outPacketFile; + outPacketFile.open(packetLimitsName.c_str(), std::ios::out); + outPacketFile << "2" << std::endl; + for (int f = 0; f < PACKET_SIZE; f ++) + { + outPacketFile << toString(mPacketLimits[f].timeLimit) + << std::endl; + } + + outPacketFile.close(); +} + +bool Client::checkPackets(int type) +{ + if (type > PACKET_SIZE) + return false; + + if (!serverConfig.getValueBool("enableBuggyServers", true)) + return true; + + int timeLimit = instance()->mPacketLimits[type].timeLimit; + + if (!timeLimit) + return true; + + int time = tick_time; + int lastTime = instance()->mPacketLimits[type].lastTime; + int cnt = instance()->mPacketLimits[type].cnt; + int cntLimit = instance()->mPacketLimits[type].cntLimit; + + if (lastTime > tick_time) + { +// instance()->mPacketLimits[type].lastTime = time; +// instance()->mPacketLimits[type].cnt = 0; + + return true; + } + else if (lastTime + timeLimit > time) + { + if (cnt >= cntLimit) + { + return false; + } + else + { +// instance()->mPacketLimits[type].cnt ++; + return true; + } + } +// instance()->mPacketLimits[type].lastTime = time; +// instance()->mPacketLimits[type].cnt = 1; + return true; +} + +bool Client::limitPackets(int type) +{ + if (type > PACKET_SIZE) + return false; + + if (!serverConfig.getValueBool("enableBuggyServers", true)) + return true; + + int timeLimit = instance()->mPacketLimits[type].timeLimit; + + if (!timeLimit) + return true; + + int time = tick_time; + int lastTime = instance()->mPacketLimits[type].lastTime; + int cnt = instance()->mPacketLimits[type].cnt; + int cntLimit = instance()->mPacketLimits[type].cntLimit; + + if (lastTime > tick_time) + { + instance()->mPacketLimits[type].lastTime = time; + instance()->mPacketLimits[type].cnt = 0; + + return true; + } + else if (lastTime + timeLimit > time) + { + if (cnt >= cntLimit) + { + return false; + } + else + { + instance()->mPacketLimits[type].cnt ++; + return true; + } + } + instance()->mPacketLimits[type].lastTime = time; + instance()->mPacketLimits[type].cnt = 1; + return true; +} + +const std::string Client::getServerConfigDirectory() +{ + return instance()->mServerConfigDir; +} + +void Client::setGuiAlpha(float n) +{ + instance()->mGuiAlpha = n; +} + +float Client::getGuiAlpha() +{ + return instance()->mGuiAlpha; +} + +void Client::setFramerate(int fpsLimit) +{ + if (!fpsLimit || !instance()->mLimitFps) + return; + + SDL_setFramerate(&instance()->mFpsManager, fpsLimit); +} -- cgit v1.2.3-70-g09d2