You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3407 lines
103 KiB
C++
3407 lines
103 KiB
C++
// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
|
|
// Copyright (C) 2010 Winch Gate Property Limited
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as
|
|
// published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
|
|
|
|
|
//////////////
|
|
// Includes //
|
|
//////////////
|
|
#include "stdpch.h"
|
|
|
|
// Misc.
|
|
#include "nel/misc/i18n.h"
|
|
#include "nel/misc/path.h"
|
|
#include "nel/misc/time_nl.h"
|
|
#include "nel/misc/algo.h"
|
|
#include "nel/misc/system_utils.h"
|
|
// 3D Interface.
|
|
#include "nel/3d/u_driver.h"
|
|
#include "nel/3d/u_text_context.h"
|
|
// Game Share
|
|
//#include "game_share/gd_time.h" // \todo GUIGUI : TO DELETE/CHANGE
|
|
#include "game_share/gender.h"
|
|
#include "game_share/character_summary.h"
|
|
#include "game_share/roles.h"
|
|
#include "game_share/character_title.h"
|
|
#include "game_share/shard_names.h"
|
|
#include "game_share/utils.h"
|
|
#include "game_share/bg_downloader_msg.h"
|
|
|
|
// Std.
|
|
#include <vector>
|
|
// Client
|
|
#include "connection.h"
|
|
#include "interface_v3/action_handler.h"
|
|
#include "sound_manager.h"
|
|
#include "input.h"
|
|
#include "login.h"
|
|
#include "login_progress_post_thread.h"
|
|
|
|
#include "client_cfg.h"
|
|
#include "actions_client.h"
|
|
#include "user_entity.h"
|
|
#include "time_client.h"
|
|
#include "net_manager.h"
|
|
#include "string_manager_client.h"
|
|
#include "http_client.h"
|
|
#include "far_tp.h"
|
|
#include "movie_shooter.h"
|
|
|
|
// Interface part
|
|
#include "interface_v3/interface_manager.h"
|
|
#include "interface_v3/character_3d.h"
|
|
#include "interface_v3/ctrl_button.h"
|
|
#include "interface_v3/input_handler_manager.h"
|
|
#include "interface_v3/group_editbox.h"
|
|
#include "interface_v3/interface_expr.h"
|
|
#include "init_main_loop.h"
|
|
#include "continent_manager.h"
|
|
#include "interface_v3/group_quick_help.h"
|
|
#include "interface_v3/dbgroup_combo_box.h"
|
|
|
|
#include "r2/dmc/client_edition_module.h"
|
|
#include "r2/editor.h"
|
|
#include "game_share/scenario.h"
|
|
#include "session_browser_impl.h"
|
|
|
|
#include "bg_downloader_access.h"
|
|
#include "main_loop.h"
|
|
|
|
|
|
////////////////
|
|
// Namespaces //
|
|
////////////////
|
|
using namespace NLMISC;
|
|
using namespace NL3D;
|
|
using namespace NLNET;
|
|
using namespace std;
|
|
using namespace RSMGR;
|
|
using namespace R2;
|
|
|
|
|
|
|
|
/////////////
|
|
// Externs //
|
|
/////////////
|
|
extern uint32 Version; // Client Version.
|
|
extern UDriver *Driver;
|
|
extern UTextContext *TextContext;
|
|
extern bool game_exit;
|
|
extern CMsgBoxDisplayer MsgBoxError;
|
|
|
|
extern CSoundManager *SoundMngr;
|
|
|
|
extern bool serverReceivedReady;
|
|
extern CContinentManager ContinentMngr;
|
|
|
|
extern bool MovieShooterSaving;
|
|
extern void endMovieShooting();
|
|
extern void replayMovieShooting();
|
|
extern void saveMovieShooting();
|
|
extern void displaySpecialTextProgress(const char *text);
|
|
extern bool InitMouseWithCursor(bool hardware);
|
|
|
|
/////////////
|
|
// Globals // initialization occurs in the function : connection
|
|
/////////////
|
|
bool userChar;
|
|
bool noUserChar;
|
|
bool ConnectInterf;
|
|
bool CreateInterf;
|
|
bool CharacterInterf;
|
|
TTime UniversalTime;
|
|
std::vector<CCharacterSummary> CharacterSummaries;
|
|
std::string UsedFSAddr;
|
|
std::string UserPrivileges;
|
|
uint8 ServerPeopleActive = 255;
|
|
uint8 ServerCareerActive = 255;
|
|
|
|
bool WaitServerAnswer;
|
|
bool CharNameValidArrived;
|
|
bool CharNameValid;
|
|
string CharNameValidDBLink;
|
|
uint8 PlayerSelectedSlot = 0;
|
|
string PlayerSelectedFileName;
|
|
TSessionId PlayerSelectedMainland= (TSessionId)0; // This is the mainland selected at the SELECT perso!!
|
|
ucstring PlayerSelectedHomeShardName;
|
|
ucstring PlayerSelectedHomeShardNameWithParenthesis;
|
|
extern std::string CurrentCookie;
|
|
|
|
|
|
ucstring NewKeysCharNameWanted; // name of the character for which a new keyset must be created
|
|
ucstring NewKeysCharNameValidated;
|
|
std::string GameKeySet = "keys.xml";
|
|
std::string RingEditorKeySet = "keys_r2ed.xml";
|
|
|
|
string ScenarioFileName;
|
|
|
|
|
|
static const char *KeySetVarName = "BuiltInKeySets";
|
|
|
|
|
|
#define GROUP_LIST_MAINLAND "ui:outgame:appear_mainland:mainland_list"
|
|
#define GROUP_LIST_KEYSET "ui:outgame:appear_keyset:keyset_list"
|
|
vector<CMainlandSummary> Mainlands;
|
|
TSessionId MainlandSelected = (TSessionId)0; // This is the mainland selected at the CREATE perso!!
|
|
|
|
// This is the home session (mainland) of the selected character
|
|
TSessionId CharacterHomeSessionId = (TSessionId)0;
|
|
|
|
|
|
bool PatchBegun = false;
|
|
|
|
// \todo GUIGUI : USE TRANSPORT CLASS.
|
|
// SVersionAnswer versionAnswer;
|
|
|
|
|
|
// Finite State Machine : all the states before entering the game
|
|
// ------------------------------------------------------------------------------------------------
|
|
TInterfaceState globalMenu();
|
|
|
|
|
|
bool hasPrivilegeDEV() { return (UserPrivileges.find(":DEV:") != std::string::npos); }
|
|
bool hasPrivilegeSGM() { return (UserPrivileges.find(":SGM:") != std::string::npos); }
|
|
bool hasPrivilegeGM() { return (UserPrivileges.find(":GM:") != std::string::npos); }
|
|
bool hasPrivilegeVG() { return (UserPrivileges.find(":VG:") != std::string::npos); }
|
|
bool hasPrivilegeSG() { return (UserPrivileges.find(":SG:") != std::string::npos); }
|
|
bool hasPrivilegeG() { return (UserPrivileges.find(":G:") != std::string::npos); }
|
|
bool hasPrivilegeEM() { return (UserPrivileges.find(":EM:") != std::string::npos); }
|
|
bool hasPrivilegeEG() { return (UserPrivileges.find(":EG:") != std::string::npos); }
|
|
|
|
|
|
// Restore the video mode (fullscreen for exemple) after the connection (done in a window)
|
|
void connectionRestaureVideoMode ()
|
|
{
|
|
// Setup full screen if we have to
|
|
UDriver::CMode mode;
|
|
Driver->getCurrentScreenMode(mode);
|
|
|
|
if (mode.Windowed)
|
|
{
|
|
uint32 width, height;
|
|
Driver->getWindowSize(width, height);
|
|
mode.Width = width;
|
|
mode.Height = height;
|
|
}
|
|
|
|
// don't allow sizes smaller than 800x600
|
|
if (ClientCfg.Width < 800) ClientCfg.Width = 800;
|
|
if (ClientCfg.Height < 600) ClientCfg.Height = 600;
|
|
|
|
if ((ClientCfg.Windowed != mode.Windowed) ||
|
|
(ClientCfg.Width != mode.Width) ||
|
|
(ClientCfg.Height != mode.Height))
|
|
{
|
|
mode.Windowed = ClientCfg.Windowed;
|
|
mode.Depth = uint8(ClientCfg.Depth);
|
|
mode.Width = ClientCfg.Width;
|
|
mode.Height = ClientCfg.Height;
|
|
mode.Frequency= ClientCfg.Frequency;
|
|
setVideoMode(mode);
|
|
}
|
|
|
|
// And setup hardware mouse if we have to
|
|
InitMouseWithCursor (ClientCfg.HardwareCursor);
|
|
SetMouseFreeLook ();
|
|
SetMouseCursor ();
|
|
SetMouseSpeed (ClientCfg.CursorSpeed);
|
|
SetMouseAcceleration (ClientCfg.CursorAcceleration);
|
|
}
|
|
|
|
|
|
#define GROUP_BROWSER "ui:outgame:charsel:webstart:content:webstart_html"
|
|
#define UI_VARIABLES_SCREEN_WEBSTART 8
|
|
|
|
|
|
// ***************************************************************************
|
|
// Called to reload the start test page in test browser mode
|
|
class CAHOnReloadTestPage: public IActionHandler
|
|
{
|
|
virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
|
|
{
|
|
CInterfaceManager *pIM = CInterfaceManager::getInstance();
|
|
// need to reset password and current screen
|
|
CGroupHTML *pGH = dynamic_cast<CGroupHTML*>(pIM->getElementFromId(GROUP_BROWSER));
|
|
|
|
pGH->browse(ClientCfg.TestBrowserUrl.c_str());
|
|
|
|
}
|
|
};
|
|
REGISTER_ACTION_HANDLER (CAHOnReloadTestPage, "on_reload_test_page");
|
|
|
|
|
|
void initWebBrowser()
|
|
{
|
|
CInterfaceManager *pIM = CInterfaceManager::getInstance();
|
|
//pIM->getDbProp("UI:VARIABLES:SCREEN")->setValue32(UI_VARIABLES_SCREEN_WEBSTART);
|
|
|
|
// start the browser
|
|
CGroupHTML *pGH = dynamic_cast<CGroupHTML*>(pIM->getElementFromId(GROUP_BROWSER));
|
|
|
|
if (pGH)
|
|
{
|
|
pGH->setActive(true);
|
|
pGH->browse(ClientCfg.PatchletUrl.c_str());
|
|
}
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
void setOutGameFullScreen()
|
|
{
|
|
// Setup full screen (special 1024x768 for outgame) if we have to.
|
|
// NB: don't setup fullscreen if player wants to play in window
|
|
if (!ClientCfg.Local && ClientCfg.SelectCharacter == -1)
|
|
{
|
|
UDriver::CMode currMode;
|
|
Driver->getCurrentScreenMode(currMode);
|
|
UDriver::CMode wantedMode;
|
|
wantedMode.Windowed = true;
|
|
wantedMode.Width = 1024;
|
|
wantedMode.Height = 768;
|
|
wantedMode.Depth = uint8(ClientCfg.Depth);
|
|
wantedMode.Frequency = ClientCfg.Frequency;
|
|
|
|
// change mode only if necessary
|
|
if ((wantedMode.Windowed != currMode.Windowed) ||
|
|
(wantedMode.Width != currMode.Width) ||
|
|
(wantedMode.Height != currMode.Height))
|
|
{
|
|
setVideoMode(wantedMode);
|
|
}
|
|
/*
|
|
InitMouseWithCursor (true);
|
|
Driver->showCursor(false);
|
|
Driver->showCursor(true);
|
|
Driver->clearBuffers(CRGBA::Black);
|
|
Driver->swapBuffers();
|
|
Driver->showCursor(false);
|
|
Driver->showCursor(true);
|
|
*/
|
|
}
|
|
|
|
}
|
|
|
|
|
|
// New version of the menu after the server connection
|
|
//
|
|
// If you add something in this function, check CFarTP,
|
|
// some kind of reinitialization might be useful over there.
|
|
// ------------------------------------------------------------------------------------------------
|
|
bool connection (const string &cookie, const string &fsaddr)
|
|
{
|
|
|
|
NLMISC::TTime connStart = ryzomGetLocalTime();
|
|
NLMISC::TTime connLast = connStart;
|
|
NLMISC::TTime connCurrent = connLast;
|
|
|
|
game_exit = false;
|
|
|
|
// Setup full screen (special 1024x768 for outgame) if we have to.
|
|
setOutGameFullScreen();
|
|
|
|
// Preload continents
|
|
{
|
|
const ucstring nmsg("Loading continents...");
|
|
ProgressBar.newMessage (ClientCfg.buildLoadingString(nmsg) );
|
|
ContinentMngr.preloadSheets();
|
|
|
|
connLast = connCurrent;
|
|
connCurrent = ryzomGetLocalTime();
|
|
nlinfo ("PROFILE: %d seconds (%d total) for Loading continents", (uint32)(connCurrent-connLast)/1000, (uint32)(connCurrent-connStart)/1000);
|
|
}
|
|
|
|
if (!fsaddr.empty () && !cookie.empty ())
|
|
{
|
|
// it means that we have a nel_launcher values, so we are online
|
|
ClientCfg.Local = 0;
|
|
nlinfo ("Using the nel launcher parameters '%s' '%s'", cookie.c_str (), fsaddr.c_str ());
|
|
}
|
|
|
|
CInterfaceManager *pIM = CInterfaceManager::getInstance();
|
|
|
|
// If the Client is in in Local Mode -> init the Time and return.
|
|
if (ClientCfg.Local)
|
|
{
|
|
#ifdef ENABLE_INCOMING_MSG_RECORDER
|
|
NetMngr.init("", "");
|
|
// Set the impulse callback.
|
|
NetMngr.setImpulseCallback (impulseCallBack);
|
|
// Set the database.
|
|
NetMngr.setDataBase (IngameDbMngr.getNodePtr());
|
|
// init the string manager cache.
|
|
STRING_MANAGER::CStringManagerClient::instance()->initCache("", ClientCfg.LanguageCode); // VOIR BORIS
|
|
#endif
|
|
connectionRestaureVideoMode ();
|
|
return true;
|
|
}
|
|
|
|
ProgressBar.setFontFactor(1.0f);
|
|
|
|
// Init out game
|
|
ucstring nmsg("Initializing outgame...");
|
|
ProgressBar.newMessage (ClientCfg.buildLoadingString(nmsg) );
|
|
pIM->initOutGame();
|
|
|
|
connLast = connCurrent;
|
|
connCurrent = ryzomGetLocalTime();
|
|
nlinfo ("PROFILE: %d seconds (%d total) for Initializing outgame", (uint32)(connCurrent-connLast)/1000, (uint32)(connCurrent-connStart)/1000);
|
|
|
|
// Init user interface
|
|
nmsg = "Initializing user interface...";
|
|
ProgressBar.newMessage (ClientCfg.buildLoadingString(nmsg) );
|
|
|
|
// Hide cursor for interface
|
|
//Driver->showCursor (false);
|
|
|
|
// Init global variables
|
|
userChar = false;
|
|
noUserChar = false;
|
|
ConnectInterf = true;
|
|
CreateInterf = true;
|
|
CharacterInterf = true;
|
|
WaitServerAnswer= false;
|
|
|
|
FarTP.setOutgame();
|
|
|
|
// Start the finite state machine
|
|
static bool firstConnection = true;
|
|
TInterfaceState InterfaceState = AUTO_LOGIN;
|
|
// TInterfaceState InterfaceState = firstConnection ? AUTO_LOGIN : GLOBAL_MENU;
|
|
/*if (!firstConnection)
|
|
{
|
|
noUserChar = userChar = false;
|
|
WaitServerAnswer = true;
|
|
}*/
|
|
|
|
pIM->activateMasterGroup ("ui:outgame", true);
|
|
pIM->getDbProp ("UI:CURRENT_SCREEN")->setValue32(ClientCfg.Local ? 6 : -1); // TMP TMP
|
|
CCDBNodeBranch::flushObserversCalls();
|
|
|
|
// Active inputs
|
|
Actions.enable(true);
|
|
EditActions.enable(true);
|
|
|
|
if (ClientCfg.SelectCharacter == -1)
|
|
{
|
|
// not initialized at login and remain hardware until here ...
|
|
|
|
// Re-initialise the mouse (will be now in hardware mode, if required)
|
|
//InitMouseWithCursor (ClientCfg.HardwareCursor); // the return value of enableLowLevelMouse() has already been tested at startup
|
|
|
|
// no ui init if character selection is automatic
|
|
//SetMouseFreeLook ();
|
|
//SetMouseCursor ();
|
|
SetMouseSpeed (ClientCfg.CursorSpeed);
|
|
SetMouseAcceleration (ClientCfg.CursorAcceleration);
|
|
|
|
pIM->getDbProp("UI:SELECTED_SLOT")->setValue32(ClientCfg.SelectedSlot);
|
|
PlayerSelectedSlot = ClientCfg.SelectedSlot;
|
|
}
|
|
|
|
connLast = connCurrent;
|
|
connCurrent = ryzomGetLocalTime();
|
|
nlinfo ("PROFILE: %d seconds (%d total) for Initializing user interface", (uint32)(connCurrent-connLast)/1000, (uint32)(connCurrent-connStart)/1000);
|
|
|
|
nlinfo ("PROFILE: %d seconds for connection", (uint32)(ryzomGetLocalTime ()-connStart)/1000);
|
|
|
|
// Init web box
|
|
nlinfo("ok");
|
|
initWebBrowser();
|
|
|
|
// TMP TMP
|
|
if (ClientCfg.Local)
|
|
{
|
|
InterfaceState = GLOBAL_MENU;
|
|
}
|
|
|
|
// Create the loading texture. We can't do that before because we need to add search path first.
|
|
beginLoading (LoadBackground);
|
|
UseEscapeDuringLoading = USE_ESCAPE_DURING_LOADING;
|
|
|
|
while ((InterfaceState != GOGOGO_IN_THE_GAME) && (InterfaceState != QUIT_THE_GAME))
|
|
{
|
|
switch (InterfaceState)
|
|
{
|
|
case AUTO_LOGIN:
|
|
InterfaceState = autoLogin (cookie, fsaddr, firstConnection);
|
|
break;
|
|
|
|
case GLOBAL_MENU:
|
|
if (!ClientCfg.Local)
|
|
{
|
|
if (ClientCfg.SelectCharacter == -1)
|
|
{
|
|
pIM->getDbProp ("UI:CURRENT_SCREEN")->setValue32(0); // 0 == select
|
|
}
|
|
}
|
|
InterfaceState = globalMenu();
|
|
break;
|
|
case GOGOGO_IN_THE_GAME:
|
|
break;
|
|
case QUIT_THE_GAME:
|
|
break;
|
|
}
|
|
}
|
|
|
|
firstConnection = false;
|
|
|
|
// Disable inputs
|
|
Actions.enable(false);
|
|
EditActions.enable(false);
|
|
|
|
// resetTextContext ("ingame.ttf", true);
|
|
resetTextContext ("ryzom.ttf", true);
|
|
|
|
if (InterfaceState == GOGOGO_IN_THE_GAME)
|
|
{
|
|
// set background downloader to 'paused' to ease loading of client
|
|
pauseBGDownloader();
|
|
return true;
|
|
}
|
|
|
|
if (InterfaceState == QUIT_THE_GAME)
|
|
return false;
|
|
nlassert ((InterfaceState == GOGOGO_IN_THE_GAME) || (InterfaceState == QUIT_THE_GAME));
|
|
return true;
|
|
}
|
|
|
|
|
|
//
|
|
|
|
// Allow user to reselect character after the server reconnection
|
|
// ------------------------------------------------------------------------------------------------
|
|
bool reconnection()
|
|
{
|
|
|
|
game_exit = false;
|
|
|
|
// Setup full screen (special 1024x768 for outgame) if we have to.
|
|
setOutGameFullScreen();
|
|
|
|
// Preload continents
|
|
{
|
|
const ucstring nmsg ("Loading continents...");
|
|
ProgressBar.newMessage (ClientCfg.buildLoadingString(nmsg) );
|
|
ContinentMngr.preloadSheets();
|
|
}
|
|
/*
|
|
if (!fsaddr.empty () && !cookie.empty ())
|
|
{
|
|
// it means that we have a nel_launcher values, so we are online
|
|
ClientCfg.Local = 0;
|
|
nlinfo ("Using the nel launcher parameters '%s' '%s'", cookie.c_str (), fsaddr.c_str ());
|
|
}
|
|
|
|
// If the Client is in in Local Mode -> init the Time and return.
|
|
if (ClientCfg.Local)
|
|
{
|
|
#ifdef ENABLE_INCOMING_MSG_RECORDER
|
|
NetMngr.init("", "");
|
|
// Set the impulse callback.
|
|
NetMngr.setImpulseCallback (impulseCallBack);
|
|
// Set the database.
|
|
NetMngr.setDataBase (IngameDbMngr.getNodePtr());
|
|
// init the string manager cache.
|
|
STRING_MANAGER::CStringManagerClient::instance()->initCache("", ClientCfg.LanguageCode); // VOIR BORIS
|
|
#endif
|
|
connectionRestaureVideoMode ();
|
|
return true;
|
|
}
|
|
*/
|
|
|
|
CInterfaceManager *pIM = CInterfaceManager::getInstance();
|
|
|
|
ProgressBar.setFontFactor(1.0f);
|
|
|
|
// Init out game
|
|
pIM->initOutGame();
|
|
|
|
// Hide cursor for interface
|
|
Driver->showCursor (false);
|
|
|
|
// Init global variables
|
|
userChar = false;
|
|
noUserChar = false;
|
|
ConnectInterf = true;
|
|
CreateInterf = true;
|
|
CharacterInterf = true;
|
|
WaitServerAnswer= false;
|
|
|
|
FarTP.setOutgame();
|
|
|
|
// these two globals sequence GlobalMenu to display the character select dialog
|
|
WaitServerAnswer = true;
|
|
userChar = true;
|
|
|
|
// Start the finite state machine
|
|
TInterfaceState InterfaceState = GLOBAL_MENU;
|
|
|
|
pIM->activateMasterGroup ("ui:outgame", true);
|
|
pIM->getDbProp ("UI:CURRENT_SCREEN")->setValue32(-1);
|
|
CCDBNodeBranch::flushObserversCalls();
|
|
|
|
// Active inputs
|
|
Actions.enable(true);
|
|
EditActions.enable(true);
|
|
|
|
if (ClientCfg.SelectCharacter == -1)
|
|
{
|
|
// Re-initialise the mouse (will be now in hardware mode, if required)
|
|
InitMouseWithCursor (ClientCfg.HardwareCursor); // the return value of enableLowLevelMouse() has already been tested at startup
|
|
|
|
// no ui init if character selection is automatic
|
|
SetMouseFreeLook ();
|
|
SetMouseCursor ();
|
|
SetMouseSpeed (ClientCfg.CursorSpeed);
|
|
SetMouseAcceleration (ClientCfg.CursorAcceleration);
|
|
pIM->getDbProp("UI:SELECTED_SLOT")->setValue32(ClientCfg.SelectedSlot);
|
|
PlayerSelectedSlot = ClientCfg.SelectedSlot;
|
|
}
|
|
|
|
// we want the teleport graphics to display (not like in Server Hop mode)
|
|
// this also kicks the state machine to sendReady() so we stop spinning in farTPmainLoop
|
|
FarTP.setIngame();
|
|
|
|
// Create the loading texture. We can't do that before because we need to add search path first.
|
|
beginLoading (LoadBackground);
|
|
UseEscapeDuringLoading = USE_ESCAPE_DURING_LOADING;
|
|
|
|
// character selection menu
|
|
while( InterfaceState == GLOBAL_MENU ) // != GOGOGO_IN_THE_GAME) && (InterfaceState != QUIT_THE_GAME))
|
|
{
|
|
if (ClientCfg.SelectCharacter == -1)
|
|
{
|
|
pIM->getDbProp ("UI:CURRENT_SCREEN")->setValue32(0); // 0 == select
|
|
}
|
|
InterfaceState = globalMenu();
|
|
}
|
|
|
|
// Disable inputs
|
|
Actions.enable(false);
|
|
EditActions.enable(false);
|
|
|
|
// resetTextContext ("ingame.ttf", true);
|
|
resetTextContext ("ryzom.ttf", true);
|
|
|
|
if (InterfaceState == GOGOGO_IN_THE_GAME)
|
|
{
|
|
pauseBGDownloader();
|
|
return true;
|
|
}
|
|
if (InterfaceState == QUIT_THE_GAME)
|
|
return false;
|
|
nlassert ((InterfaceState == GOGOGO_IN_THE_GAME) || (InterfaceState == QUIT_THE_GAME));
|
|
return true;
|
|
}
|
|
|
|
// Automatic connection to the server, the user can't do anything
|
|
// ------------------------------------------------------------------------------------------------
|
|
TInterfaceState autoLogin (const string &cookie, const string &fsaddr, bool firstConnection)
|
|
{
|
|
noUserChar = userChar = false;
|
|
string defaultPort = string(":47851");
|
|
if(!fsaddr.empty())
|
|
{
|
|
// If we have a front end address from command line, use this one
|
|
UsedFSAddr = fsaddr;
|
|
if (UsedFSAddr.find(":") == string::npos)
|
|
{
|
|
UsedFSAddr += defaultPort;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Otherwise, use the front end address from configfile
|
|
UsedFSAddr = ClientCfg.FSHost;
|
|
FSAddr = UsedFSAddr; // to be able to do /reconnect
|
|
LoginSM.pushEvent( CLoginStateMachine::ev_skip_all_login );
|
|
if (UsedFSAddr.find(":") == string::npos)
|
|
{
|
|
UsedFSAddr += defaultPort;
|
|
FSAddr += defaultPort; // to be able to do /reconnect
|
|
}
|
|
}
|
|
|
|
if (firstConnection)
|
|
NetMngr.init (cookie, UsedFSAddr);
|
|
|
|
// Connection
|
|
if (!ClientCfg.Local/*ace!ClientCfg.Light*/)
|
|
{
|
|
string result;
|
|
|
|
if (firstConnection)
|
|
{
|
|
NetMngr.connect (result);
|
|
|
|
if (!result.empty())
|
|
{
|
|
nlerror ("connection : %s.", result.c_str());
|
|
return QUIT_THE_GAME;
|
|
}
|
|
|
|
// Ok the client is connected
|
|
|
|
// Set the impulse callback.
|
|
NetMngr.setImpulseCallback (impulseCallBack);
|
|
// Set the database.
|
|
NetMngr.setDataBase (IngameDbMngr.getNodePtr());
|
|
|
|
// init the string manager cache.
|
|
STRING_MANAGER::CStringManagerClient::instance()->initCache(UsedFSAddr, ClientCfg.LanguageCode);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CCharacterSummary cs;
|
|
cs.Name = "babar";
|
|
//cs.Surname = "l'elephant";
|
|
cs.People = EGSPD::CPeople::Zorai;
|
|
cs.VisualPropA.PropertySubData.Sex = 0; // Male
|
|
//Deprecated
|
|
// cs.Role = ROLES::range_warrior;
|
|
// cs.Job = JOBS::CasterBuffer;
|
|
// cs.JobLevel = 16;
|
|
CharacterSummaries.push_back(cs);
|
|
|
|
cs.Name = "yeah";
|
|
//cs.Surname = "zeelot";
|
|
cs.People = EGSPD::CPeople::Matis;
|
|
cs.VisualPropA.PropertySubData.Sex = 1; // Female
|
|
//Deprecated
|
|
// cs.Role = ROLES::buffer_magician;
|
|
// cs.Job = JOBS::CasterHealer;
|
|
// cs.JobLevel = 8;
|
|
CharacterSummaries.push_back(cs);
|
|
|
|
userChar = true;
|
|
}
|
|
|
|
WaitServerAnswer = true;
|
|
|
|
return GLOBAL_MENU;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
void globalMenuMovieShooter()
|
|
{
|
|
|
|
if(MovieShooterSaving)
|
|
{
|
|
// Add the buffer frame to the movie.
|
|
if(!MovieShooter.addFrame(TimeInSec, Driver))
|
|
{
|
|
// Fail to add the frame => abort.
|
|
endMovieShooting();
|
|
}
|
|
else
|
|
{
|
|
// Ok, just add a display.
|
|
displaySpecialTextProgress("MovieShooting");
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Build a valid PlayerName for file Save selection.
|
|
std::string buildPlayerNameForSaveFile(const ucstring &playerNameIn)
|
|
{
|
|
// remove any shard name appended
|
|
ucstring playerName = playerNameIn;
|
|
ucstring::size_type pos = playerNameIn.find('(');
|
|
if(pos!=ucstring::npos && pos>0)
|
|
{
|
|
playerName.resize(pos);
|
|
}
|
|
|
|
// replace any special ucchar with '_'
|
|
string ret;
|
|
ret.resize(playerName.size());
|
|
for(uint i=0;i<playerName.size();i++)
|
|
{
|
|
ucchar c= playerName[i];
|
|
if( (c>='A' && c<='Z') ||
|
|
(c>='a' && c<='z') ||
|
|
(c>='0' && c<='9') ||
|
|
(c=='_') )
|
|
{
|
|
ret[i]= tolower(c);
|
|
}
|
|
else
|
|
ret[i]= '_';
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
class CSoundGlobalMenu
|
|
{
|
|
public:
|
|
CSoundGlobalMenu()
|
|
{
|
|
_MusicWantedAsync= false;
|
|
_NbFrameBeforeChange= NbFrameBeforeChangeMax;
|
|
}
|
|
void setMusic(const string &music, bool async);
|
|
void updateSound();
|
|
private:
|
|
string _MusicPlayed;
|
|
string _MusicWanted;
|
|
bool _MusicWantedAsync;
|
|
sint _NbFrameBeforeChange;
|
|
enum {NbFrameBeforeChangeMax= 10};
|
|
};
|
|
|
|
void CSoundGlobalMenu::updateSound()
|
|
{
|
|
// **** update the music played
|
|
// The first music played is the music played at loading, before select char
|
|
if(_MusicPlayed.empty())
|
|
_MusicPlayed= toLower(ClientCfg.SoundOutGameMusic);
|
|
if(_MusicWanted.empty())
|
|
_MusicWanted= toLower(ClientCfg.SoundOutGameMusic);
|
|
|
|
// because music is changed when the player select other race for instance,
|
|
// wait the 3D to load (stall some secs)
|
|
|
|
// if the wanted music is the same as the one currently playing, just continue playing
|
|
if(_MusicPlayed!=_MusicWanted)
|
|
{
|
|
// wait nbFrameBeforeChangeMax before actually changing the music
|
|
_NbFrameBeforeChange--;
|
|
if(_NbFrameBeforeChange<=0)
|
|
{
|
|
_MusicPlayed= _MusicWanted;
|
|
// play the music
|
|
if (SoundMngr != NULL)
|
|
SoundMngr->playMusic(_MusicPlayed, 500, _MusicWantedAsync, true, true);
|
|
}
|
|
}
|
|
|
|
|
|
// **** update mngr
|
|
if (SoundMngr != NULL)
|
|
SoundMngr->update();
|
|
}
|
|
|
|
void CSoundGlobalMenu::setMusic(const string &music, bool async)
|
|
{
|
|
_MusicWanted= toLower(music);
|
|
_MusicWantedAsync= async;
|
|
// reset the counter
|
|
_NbFrameBeforeChange= NbFrameBeforeChangeMax;
|
|
}
|
|
static CSoundGlobalMenu SoundGlobalMenu;
|
|
|
|
|
|
static bool LuaBGDSuccessFlag = true; // tmp, for debug
|
|
|
|
|
|
void updateBGDownloaderUI()
|
|
{
|
|
CInterfaceManager *im = CInterfaceManager::getInstance();
|
|
CBGDownloaderAccess &bgDownloader = CBGDownloaderAccess::getInstance();
|
|
bool bgWindowVisible = true;
|
|
if (im->isInGame())
|
|
{
|
|
static NLMISC::CRefPtr<CInterfaceElement> bgDownloaderWindow;
|
|
if (!bgDownloaderWindow)
|
|
{
|
|
bgDownloaderWindow = im->getElementFromId("ui:interface:bg_downloader");
|
|
}
|
|
bgWindowVisible = bgDownloaderWindow && bgDownloaderWindow->getActive();
|
|
}
|
|
bool prevSuccess = LuaBGDSuccessFlag;
|
|
if (isBGDownloadEnabled() && PatchBegun)
|
|
{
|
|
if (AvailablePatchs == 0)
|
|
{
|
|
if (LuaBGDSuccessFlag)
|
|
{
|
|
LuaBGDSuccessFlag = im->executeLuaScript("bgdownloader:setPatchSuccess()");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch(bgDownloader.getLastTaskResult())
|
|
{
|
|
case BGDownloader::TaskResult_Unknown:
|
|
{
|
|
float progress = 0.f;
|
|
/*if (bgDownloader.getTotalSize() != 0)
|
|
{
|
|
progress = (float) bgDownloader.getPatchingSize() / bgDownloader.getTotalSize();
|
|
}*/
|
|
if (bgDownloader.getTotalFilesToGet() != 0)
|
|
{
|
|
progress = (bgDownloader.getCurrentFilesToGet() + bgDownloader.getCurrentFileProgress()) / bgDownloader.getTotalFilesToGet();
|
|
}
|
|
if (LuaBGDSuccessFlag && bgWindowVisible)
|
|
{
|
|
LuaBGDSuccessFlag = im->executeLuaScript(toString("bgdownloader:setPatchProgress(%f)", progress));
|
|
}
|
|
// display current priority of the downloader
|
|
if (LuaBGDSuccessFlag && bgWindowVisible)
|
|
{
|
|
LuaBGDSuccessFlag = im->executeLuaScript("bgdownloader:displayPriority()");
|
|
}
|
|
}
|
|
break;
|
|
case BGDownloader::TaskResult_Success:
|
|
if (LuaBGDSuccessFlag && bgWindowVisible)
|
|
{
|
|
LuaBGDSuccessFlag = im->executeLuaScript("bgdownloader:setPatchSuccess()");
|
|
}
|
|
// task finished
|
|
AvailablePatchs = 0;
|
|
if (bgDownloader.getPatchCompletionFlag(true /* clear flag */))
|
|
{
|
|
// when in-game, display a message to signal the end of the patch
|
|
if (im->isInGame())
|
|
{
|
|
im->displaySystemInfo(CI18N::get("uiBGD_InGamePatchCompletion"), "BC");
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
// error case
|
|
if (LuaBGDSuccessFlag && bgWindowVisible)
|
|
{
|
|
LuaBGDSuccessFlag = im->executeLuaScript("bgdownloader:setPatchError()");
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (LuaBGDSuccessFlag && bgWindowVisible)
|
|
{
|
|
if (isBGDownloadEnabled())
|
|
{
|
|
// no necessary patch for now
|
|
LuaBGDSuccessFlag = im->executeLuaScript("bgdownloader:setNoNecessaryPatch()");
|
|
}
|
|
else
|
|
{
|
|
// no download ui
|
|
LuaBGDSuccessFlag = im->executeLuaScript("bgdownloader:setNoDownloader()");
|
|
}
|
|
}
|
|
}
|
|
if (prevSuccess != LuaBGDSuccessFlag)
|
|
{
|
|
nlwarning("Some scipt error occured");
|
|
}
|
|
}
|
|
|
|
|
|
// compute patcher priority, depending on the presence of one or more mainland characters : in this case, give the patch a boost
|
|
void updatePatcherPriorityBasedOnCharacters()
|
|
{
|
|
if (isBGDownloadEnabled())
|
|
{
|
|
if (CBGDownloaderAccess::getInstance().getDownloadThreadPriority() != BGDownloader::ThreadPriority_Paused)
|
|
{
|
|
// choose priority based on available characters :
|
|
bool hasMainlandChar = false;
|
|
for(std::vector<CCharacterSummary>::iterator it = CharacterSummaries.begin(); it != CharacterSummaries.end(); ++it)
|
|
{
|
|
if (it->Name.empty()) continue;
|
|
if (!it->InNewbieland)
|
|
{
|
|
hasMainlandChar = true;
|
|
break;
|
|
}
|
|
}
|
|
CBGDownloaderAccess::getInstance().requestDownloadThreadPriority(hasMainlandChar ? BGDownloader::ThreadPriority_Normal : BGDownloader::ThreadPriority_Low, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Launch the interface to choose a character
|
|
// ------------------------------------------------------------------------------------------------
|
|
TInterfaceState globalMenu()
|
|
{
|
|
CLoginProgressPostThread::getInstance().step(CLoginStep(LoginStep_CharacterSelection, "login_step_character_selection"));
|
|
|
|
CBGDownloaderAccess &bgDownloader = CBGDownloaderAccess::getInstance();
|
|
|
|
if (isBGDownloadEnabled())
|
|
{
|
|
// If there's a need for mainland download, then proceed
|
|
if (AvailablePatchs & (1 << BGDownloader::DownloadID_MainLand))
|
|
{
|
|
// if a task is already started, then this was a situation where player went back from game to the character selection,
|
|
// so just unpause
|
|
BGDownloader::TTaskResult dummyResult;
|
|
ucstring dummyMessage;
|
|
if (!bgDownloader.isTaskEnded(dummyResult, dummyMessage))
|
|
{
|
|
unpauseBGDownloader();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
CInterfaceManager *pIM = CInterfaceManager::getInstance();
|
|
|
|
sint32 nScreenConnecting, nScreenIntro, nScreenServerCrashed;
|
|
fromString(pIM->getDefine("screen_connecting"), nScreenConnecting);
|
|
fromString(pIM->getDefine("screen_intro"), nScreenIntro);
|
|
fromString(pIM->getDefine("screen_crashing"), nScreenServerCrashed);
|
|
|
|
// SKIP INTRO : Write to the database if we have to skip the intro and write we want to skip further intro to client cfg
|
|
if (ClientCfg.SkipIntro)
|
|
{
|
|
CCDBNodeLeaf *pNL = pIM->getDbProp("UI:TEMP:SKIP_INTRO", false);
|
|
if (pNL != NULL)
|
|
pNL->setValue64(1);
|
|
}
|
|
|
|
TGameCycle serverTick = NetMngr.getCurrentServerTick();
|
|
bool PlayerWantToGoInGame = false;
|
|
bool firewallTimeout = false;
|
|
|
|
ProgressBar.finish(); // no progress while selecting character
|
|
|
|
while (PlayerWantToGoInGame == false)
|
|
{
|
|
|
|
#if defined(NL_OS_WINDOWS) && defined(NL_DEBUG)
|
|
// tmp for debug
|
|
if (::GetAsyncKeyState(VK_SPACE))
|
|
{
|
|
pIM->uninitOutGame();
|
|
pIM->initOutGame();
|
|
pIM->activateMasterGroup ("ui:outgame", true);
|
|
pIM->getDbProp ("UI:CURRENT_SCREEN")->setValue32(2); // TMP TMP
|
|
CCDBNodeBranch::flushObserversCalls();
|
|
pIM->getElementFromId("ui:outgame:charsel")->setActive(false);
|
|
pIM->getElementFromId("ui:outgame:charsel")->setActive(true);
|
|
// Active inputs
|
|
Actions.enable(true);
|
|
EditActions.enable(true);
|
|
LuaBGDSuccessFlag = true;
|
|
pIM->reloadAllLuaFileScripts();
|
|
}
|
|
#endif
|
|
|
|
updateBGDownloaderUI();
|
|
|
|
|
|
// Update network.
|
|
try
|
|
{
|
|
if ( ! firewallTimeout )
|
|
NetMngr.update();
|
|
}
|
|
catch (const EBlockedByFirewall&)
|
|
{
|
|
if ( NetMngr.getConnectionState() == CNetManager::Disconnect )
|
|
{
|
|
firewallTimeout = true;
|
|
}
|
|
else
|
|
{
|
|
// Display the firewall alert string
|
|
CViewText *pVT = dynamic_cast<CViewText*>(pIM->getElementFromId("ui:outgame:connecting:title"));
|
|
if (pVT != NULL)
|
|
pVT->setText(CI18N::get("uiFirewallAlert")+ucstring("..."));
|
|
|
|
// The mouse and fullscreen mode should be unlocked for the user to set the firewall permission
|
|
nlSleep( 30 ); // 'nice' the client, and prevent to make too many send attempts
|
|
}
|
|
|
|
}
|
|
CCDBNodeBranch::flushObserversCalls();
|
|
|
|
// check if we can send another dated block
|
|
if (NetMngr.getCurrentServerTick() != serverTick)
|
|
{
|
|
//
|
|
serverTick = NetMngr.getCurrentServerTick();
|
|
NetMngr.send(serverTick);
|
|
}
|
|
else
|
|
{
|
|
// Send dummy info
|
|
NetMngr.send();
|
|
}
|
|
// Update the DT T0 and T1 global variables
|
|
updateClientTime();
|
|
CInputHandlerManager::getInstance()->pumpEvents();
|
|
Driver->clearBuffers(CRGBA::Black);
|
|
Driver->setMatrixMode2D11();
|
|
|
|
// Update sound
|
|
SoundGlobalMenu.updateSound();
|
|
|
|
// Interface handling & displaying (processes clicks...)
|
|
pIM->updateFrameEvents();
|
|
pIM->updateFrameViews(NULL);
|
|
CCDBNodeBranch::flushObserversCalls();
|
|
|
|
// Movie shooter
|
|
globalMenuMovieShooter();
|
|
|
|
// Force the client to sleep a bit.
|
|
if(ClientCfg.Sleep >= 0)
|
|
{
|
|
nlSleep(ClientCfg.Sleep);
|
|
}
|
|
|
|
#if defined(NL_OS_WINDOWS) && defined(NL_DEBUG)
|
|
if (::GetAsyncKeyState(VK_CONTROL))
|
|
{
|
|
pIM->displayUIViewBBoxs("");
|
|
pIM->displayUICtrlBBoxs("");
|
|
pIM->displayUIGroupBBoxs("");
|
|
displayDebugUIUnderMouse();
|
|
}
|
|
#endif
|
|
|
|
// Display
|
|
Driver->swapBuffers();
|
|
|
|
// SERVER INTERACTIONS WITH INTERFACE
|
|
if (WaitServerAnswer)
|
|
{
|
|
if (noUserChar || userChar)
|
|
{
|
|
|
|
if (isBGDownloadEnabled())
|
|
{
|
|
// If there's a need for mainland download, then proceed
|
|
if (AvailablePatchs & (1 << BGDownloader::DownloadID_MainLand))
|
|
{
|
|
// if a task is already started, then this was a situation where player went back from game to the character selection,
|
|
// so just unpause
|
|
BGDownloader::TTaskResult dummyResult;
|
|
ucstring dummyMessage;
|
|
if (bgDownloader.isTaskEnded(dummyResult, dummyMessage))
|
|
{
|
|
// launch mainland patch as a background task
|
|
BGDownloader::CTaskDesc task(BGDownloader::DLState_GetAndApplyPatch,
|
|
(1 << BGDownloader::DownloadID_MainLand));
|
|
bgDownloader.startTask(task, getBGDownloaderCommandLine(), false /* showDownloader */);
|
|
|
|
// choose priority based on available characters :
|
|
updatePatcherPriorityBasedOnCharacters();
|
|
|
|
PatchBegun = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
//nlinfo("impulseCallBack : received userChars list");
|
|
noUserChar = userChar = false;
|
|
if( FarTP.isReselectingChar() || !FarTP.isServerHopInProgress() ) // if doing a Server Hop, expect serverReceivedReady without action from the user
|
|
{
|
|
WaitServerAnswer = false;
|
|
if (ClientCfg.SelectCharacter == -1)
|
|
{
|
|
CCDBNodeLeaf *pNL = pIM->getDbProp("UI:SERVER_RECEIVED_CHARS", false);
|
|
if (pNL != NULL)
|
|
{
|
|
pNL->setValue64 (1); // Send impulse to interface observers
|
|
CCDBNodeBranch::flushObserversCalls();
|
|
pNL->setValue64 (0);
|
|
CCDBNodeBranch::flushObserversCalls();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// check that the pre selected character is available
|
|
if (CharacterSummaries[ClientCfg.SelectCharacter].People == EGSPD::CPeople::Unknown)
|
|
{
|
|
// BAD ! preselected char does not exist, use the first available or fail
|
|
uint i;
|
|
for (i=0; i<CharacterSummaries.size(); ++i)
|
|
{
|
|
if (CharacterSummaries[i].People != EGSPD::CPeople::Unknown)
|
|
break;
|
|
}
|
|
if (i == CharacterSummaries.size())
|
|
{
|
|
Driver->systemMessageBox("You have no character for the current user.\nClient will exit.", "Char loading error", UDriver::okType, UDriver::exclamationIcon);
|
|
exit(-1);
|
|
}
|
|
else
|
|
{
|
|
UDriver::TMessageBoxId ret = Driver->systemMessageBox("The pre-selected character doesn't exist.\nDo you want to use the first available character instead ?", "Char loading error", UDriver::yesNoType, UDriver::warningIcon);
|
|
if (ret == UDriver::noId)
|
|
exit(-1);
|
|
else
|
|
ClientCfg.SelectCharacter = i;
|
|
}
|
|
}
|
|
|
|
// Auto-selection for fast launching (dev only)
|
|
pIM->runActionHandler("launch_game", NULL, toString("slot=%d|edit_mode=0", ClientCfg.SelectCharacter));
|
|
}
|
|
|
|
}
|
|
|
|
// Clear sending buffer that may contain prevous QUIT_GAME when getting back to the char selection screen
|
|
NetMngr.flushSendBuffer();
|
|
}
|
|
|
|
if (CharNameValidArrived)
|
|
{
|
|
//nlinfo("impulseCallBack : received CharNameValidArrived");
|
|
CharNameValidArrived = false;
|
|
WaitServerAnswer = false;
|
|
if (ClientCfg.SelectCharacter == -1)
|
|
{
|
|
CCDBNodeLeaf *pNL;
|
|
pNL = pIM->getDbProp(CharNameValidDBLink,false);
|
|
if (pNL != NULL)
|
|
{
|
|
if (CharNameValid)
|
|
pNL->setValue64(1);
|
|
else
|
|
pNL->setValue64(0);
|
|
}
|
|
|
|
pNL = pIM->getDbProp("UI:SERVER_RECEIVED_VALID", false);
|
|
if (pNL != NULL)
|
|
{
|
|
pNL->setValue64 (1); // Send impulse to interface observers
|
|
CCDBNodeBranch::flushObserversCalls();
|
|
pNL->setValue64 (0);
|
|
CCDBNodeBranch::flushObserversCalls();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (serverReceivedReady)
|
|
{
|
|
//nlinfo("impulseCallBack : received serverReceivedReady");
|
|
serverReceivedReady = false;
|
|
WaitServerAnswer = false;
|
|
PlayerWantToGoInGame = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
noUserChar = false;
|
|
userChar = false;
|
|
CharNameValidArrived = false;
|
|
serverReceivedReady = false;
|
|
}
|
|
|
|
// Check if server disconnect the client
|
|
if (!ClientCfg.Local)
|
|
{
|
|
if (NetMngr.getConnectionState() == CNetManager::Disconnect)
|
|
{
|
|
// Display the connection failure screen
|
|
CCDBNodeLeaf *pNL = pIM->getDbProp("UI:CURRENT_SCREEN", false);
|
|
if (pNL != NULL)
|
|
pNL->setValue64 (nScreenServerCrashed);
|
|
|
|
if ( firewallTimeout )
|
|
{
|
|
// Display the firewall error string instead of the normal failure string
|
|
CViewText *pVT = dynamic_cast<CViewText*>(pIM->getElementFromId("ui:outgame:crashing:title"));
|
|
if (pVT != NULL)
|
|
{
|
|
pVT->setMultiLine( true );
|
|
pVT->setText(CI18N::get("uiFirewallFail")+ucstring(".\n")+
|
|
CI18N::get("uiFirewallAlert")+ucstring("."));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// We want to quit the game without playing
|
|
if (game_exit)
|
|
return QUIT_THE_GAME;
|
|
}
|
|
|
|
if (ClientCfg.SelectCharacter != -1)
|
|
PlayerSelectedSlot = ClientCfg.SelectCharacter;
|
|
|
|
// Notify the state machine that we're exiting from global menu
|
|
LoginSM.pushEvent(CLoginStateMachine::ev_global_menu_exited);
|
|
|
|
// Init the current Player Name (for interface.cfg and sentence.name save). Make a good File Name.
|
|
ucstring &playerName= CharacterSummaries[PlayerSelectedSlot].Name;
|
|
PlayerSelectedFileName= buildPlayerNameForSaveFile(playerName);
|
|
|
|
// Init the current Player Home shard Id and name
|
|
CharacterHomeSessionId = CharacterSummaries[PlayerSelectedSlot].Mainland;
|
|
PlayerSelectedMainland= CharacterSummaries[PlayerSelectedSlot].Mainland;
|
|
PlayerSelectedHomeShardName.clear();
|
|
PlayerSelectedHomeShardNameWithParenthesis.clear();
|
|
for(uint i=0;i<CShardNames::getInstance().getSessionNames().size();i++)
|
|
{
|
|
const CShardNames::TSessionName &sessionName= CShardNames::getInstance().getSessionNames()[i];
|
|
if(PlayerSelectedMainland == sessionName.SessionId)
|
|
{
|
|
PlayerSelectedHomeShardName= sessionName.DisplayName;
|
|
PlayerSelectedHomeShardNameWithParenthesis= '(' + PlayerSelectedHomeShardName + ')';
|
|
}
|
|
}
|
|
|
|
|
|
// Restaure video mode
|
|
if (ClientCfg.SelectCharacter == -1)
|
|
{
|
|
connectionRestaureVideoMode ();
|
|
}
|
|
|
|
// Skip intro next time
|
|
ClientCfg.writeBool("SkipIntro", true);
|
|
|
|
// return SELECT_CHARACTER;
|
|
return GOGOGO_IN_THE_GAME;
|
|
}
|
|
|
|
|
|
// Init the character selection slot texts from the character summaries
|
|
// ------------------------------------------------------------------------------------------------
|
|
class CAHNetInitCharSel : public IActionHandler
|
|
{
|
|
public:
|
|
virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
|
|
{
|
|
string sPath = getParam(Params, "slottexts");
|
|
CInterfaceManager *pIM = CInterfaceManager::getInstance();
|
|
uint i;
|
|
for (i = 0; i < CharacterSummaries.size(); ++i)
|
|
{
|
|
CCharacterSummary &rCS = CharacterSummaries[i];
|
|
CInterfaceElement *pIE = pIM->getElementFromId(sPath+":text"+NLMISC::toString(i));
|
|
CViewText *pVT = dynamic_cast<CViewText*>(pIE);
|
|
if (pVT == NULL) return;
|
|
|
|
if (rCS.Name.empty())
|
|
pVT->setText(CI18N::get("uiEmptySlot"));
|
|
else
|
|
pVT->setText(rCS.Name);
|
|
}
|
|
// 5 slots
|
|
for (; i < 5; ++i)
|
|
{
|
|
CViewText *pVT = dynamic_cast<CViewText*>(pIM->getElementFromId(sPath+":text"+NLMISC::toString(i)));
|
|
if (pVT == NULL) return;
|
|
pVT->setText(CI18N::get("uiEmptySlot"));
|
|
}
|
|
}
|
|
};
|
|
REGISTER_ACTION_HANDLER (CAHNetInitCharSel, "net_init_char_sel");
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
void setTarget(CCtrlBase *ctrl, const string &targetName, ucstring &value)
|
|
{
|
|
std::vector<CInterfaceLink::CTargetInfo> targets;
|
|
// find first enclosing group
|
|
CCtrlBase *currCtrl = ctrl;
|
|
CInterfaceGroup *ig = NULL;
|
|
while (currCtrl)
|
|
{
|
|
ig = dynamic_cast<CInterfaceGroup *>(currCtrl);
|
|
if (ig != NULL) break;
|
|
currCtrl = currCtrl->getParent();
|
|
}
|
|
if (ig)
|
|
{
|
|
CInterfaceExprValue exprValue;
|
|
exprValue.setUCString(value);
|
|
|
|
CInterfaceParser::splitLinkTargets(targetName, ig, targets);
|
|
for(uint k = 0; k < targets.size(); ++k)
|
|
{
|
|
if (targets[k].Elem) targets[k].affect(exprValue);
|
|
}
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
void setTarget(CCtrlBase *ctrl, const string &targetName, uint32 value)
|
|
{
|
|
std::vector<CInterfaceLink::CTargetInfo> targets;
|
|
// find first enclosing group
|
|
CCtrlBase *currCtrl = ctrl;
|
|
CInterfaceGroup *ig = NULL;
|
|
while (currCtrl)
|
|
{
|
|
ig = dynamic_cast<CInterfaceGroup *>(currCtrl);
|
|
if (ig != NULL) break;
|
|
currCtrl = currCtrl->getParent();
|
|
}
|
|
if (ig)
|
|
{
|
|
CInterfaceExprValue exprValue;
|
|
exprValue.setInteger(value);
|
|
|
|
CInterfaceParser::splitLinkTargets(targetName, ig, targets);
|
|
for(uint k = 0; k < targets.size(); ++k)
|
|
{
|
|
if (targets[k].Elem) targets[k].affect(exprValue);
|
|
}
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
class CAHGetSlot: public IActionHandler
|
|
{
|
|
public:
|
|
virtual void execute (CCtrlBase *pCaller, const string &Params)
|
|
{
|
|
string sProp = getParam(Params, "prop");
|
|
string sTarget = getParam(Params, "target");
|
|
string sSlot = getParam(Params, "slot");
|
|
|
|
CInterfaceExprValue result;
|
|
if (!CInterfaceExpr::eval(sSlot, result))
|
|
return;
|
|
uint8 selectedSlot = (uint8)result.getInteger();
|
|
if (selectedSlot >= CharacterSummaries.size())
|
|
return;
|
|
|
|
PlayerSelectedSlot = selectedSlot;
|
|
|
|
if (CharacterSummaries[PlayerSelectedSlot].Name.empty())
|
|
return;
|
|
|
|
ucstring sValue("");
|
|
uint32 nValue = 0;
|
|
|
|
if (sProp == "name")
|
|
{
|
|
sValue = CharacterSummaries[PlayerSelectedSlot].Name;
|
|
setTarget (pCaller, sTarget, sValue);
|
|
}
|
|
/* else if (sProp == "surname")
|
|
Deprecated {
|
|
sValue = CharacterSummaries[PlayerSelectedSlot].Surname;
|
|
setTarget (pCaller, sTarget, sValue);
|
|
}
|
|
*/ else if (sProp == "title")
|
|
{
|
|
bool womenTitle;
|
|
if( CharacterSummaries[PlayerSelectedSlot].VisualPropA.PropertySubData.Sex == 1 )
|
|
{
|
|
UserEntity->setGender( GSGENDER::female );
|
|
womenTitle = true;
|
|
}
|
|
else
|
|
{
|
|
UserEntity->setGender( GSGENDER::male );
|
|
womenTitle = false;
|
|
}
|
|
string titleStr = CHARACTER_TITLE::toString(CharacterSummaries[PlayerSelectedSlot].Title);
|
|
sValue = STRING_MANAGER::CStringManagerClient::getTitleLocalizedName(titleStr,womenTitle);
|
|
setTarget (pCaller, sTarget, sValue);
|
|
}
|
|
/* else if (sProp == "orient")
|
|
Deprecated {
|
|
sValue = ROLES::roleToUCString(CharacterSummaries[PlayerSelectedSlot].Role);
|
|
setTarget (pCaller, sTarget, sValue);
|
|
}
|
|
else if (sProp == "job")
|
|
{
|
|
//Deprecated
|
|
// sValue = JOBS::jobToUCString(CharacterSummaries[PlayerSelectedSlot].Job);
|
|
sValue = JOBS::jobToUCString(JOBS::BladeBearer);
|
|
setTarget (pCaller, sTarget, sValue);
|
|
}
|
|
*/ else if (sProp == "level")
|
|
{
|
|
//Deprecated
|
|
// sValue = toString(CharacterSummaries[PlayerSelectedSlot].JobLevel);
|
|
sValue = toString(1);
|
|
setTarget (pCaller, sTarget, sValue);
|
|
}
|
|
else if (sProp == "pos")
|
|
{
|
|
nValue = CharacterSummaries[PlayerSelectedSlot].Location;
|
|
setTarget (pCaller, sTarget, nValue);
|
|
}
|
|
}
|
|
};
|
|
REGISTER_ACTION_HANDLER (CAHGetSlot, "get_slot");
|
|
|
|
|
|
// Setup the database from a database entry which represents a slot
|
|
// ------------------------------------------------------------------------------------------------
|
|
class CAHSetDBFromSlot : public IActionHandler
|
|
{
|
|
public:
|
|
virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
|
|
{
|
|
string sDBLink = getParam(Params, "dblink");
|
|
string sSlot = getParam(Params, "slot");
|
|
|
|
CInterfaceExprValue result;
|
|
if (!CInterfaceExpr::eval(sSlot, result))
|
|
return;
|
|
|
|
PlayerSelectedSlot = (uint8)result.getInteger();
|
|
|
|
if (PlayerSelectedSlot >= CharacterSummaries.size())
|
|
return;
|
|
|
|
// Setup the database from the character summary
|
|
CCharacterSummary &rCS = CharacterSummaries[PlayerSelectedSlot];
|
|
if (rCS.Name.empty())
|
|
return;
|
|
|
|
SCharacter3DSetup::setupDBFromCharacterSummary(sDBLink, rCS);
|
|
}
|
|
};
|
|
REGISTER_ACTION_HANDLER (CAHSetDBFromSlot, "set_db_from_slot");
|
|
|
|
|
|
// Reset all the pushed radio button of a group
|
|
// ------------------------------------------------------------------------------------------------
|
|
class CAHResetPushed: public IActionHandler
|
|
{
|
|
public:
|
|
virtual void execute (CCtrlBase *pCaller, const string &Params)
|
|
{
|
|
string sDBLink = getParam(Params, "dblink");
|
|
CInterfaceManager *pIM = CInterfaceManager::getInstance();
|
|
CInterfaceElement *pIE = pIM->getElementFromId(pCaller->getId(), sDBLink);
|
|
CInterfaceGroup *pIG = dynamic_cast<CInterfaceGroup*>(pIE);
|
|
if (pIG == NULL) return;
|
|
|
|
const vector<CCtrlBase*> vCB = pIG->getControls();
|
|
for (uint i = 0; i < vCB.size(); ++i)
|
|
{
|
|
CCtrlBaseButton *pBut = dynamic_cast<CCtrlBaseButton*>(vCB[i]);
|
|
if (pBut && pBut->getType() == CCtrlBaseButton::RadioButton)
|
|
{
|
|
pBut->setPushed (false);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
REGISTER_ACTION_HANDLER (CAHResetPushed, "reset_pushed");
|
|
|
|
|
|
|
|
|
|
|
|
// Launch the game given a slot (slot is reference to the character summaries
|
|
// ------------------------------------------------------------------------------------------------
|
|
class CAHLaunchGame : public IActionHandler
|
|
{
|
|
public:
|
|
virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
|
|
{
|
|
// Get the edit/play mode
|
|
string sEditMode = getParam(Params, "edit_mode");
|
|
bool wantsEditMode = false;
|
|
CInterfaceExprValue result;
|
|
bool wantsNewScenario = false;
|
|
|
|
if (CInterfaceExpr::eval(sEditMode, result))
|
|
{
|
|
wantsEditMode = (result.getInteger() == 1) || (result.getInteger() == 2);
|
|
wantsNewScenario = (result.getInteger() == 2);
|
|
}
|
|
|
|
CInterfaceManager *im = CInterfaceManager::getInstance();
|
|
if (wantsEditMode)
|
|
{
|
|
// full patch needed for edition, warn the client
|
|
if (AvailablePatchs != 0)
|
|
{
|
|
if (im->isInGame())
|
|
{
|
|
inGamePatchUncompleteWarning();
|
|
}
|
|
else
|
|
{
|
|
im->messageBoxWithHelp(CI18N::get("uiBGD_FullPatchNeeded"), "ui:outgame");
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Get the player selected slot
|
|
string sSlot = getParam(Params, "slot");
|
|
if (sSlot != "ingame_auto")
|
|
{
|
|
CInterfaceExprValue result;
|
|
if (!CInterfaceExpr::eval(sSlot, result))
|
|
return;
|
|
PlayerSelectedSlot = (uint8)result.getInteger();
|
|
if (PlayerSelectedSlot >= CharacterSummaries.size())
|
|
return;
|
|
|
|
ClientCfg.writeInt("SelectedSlot",PlayerSelectedSlot);
|
|
if (ClientCfg.SaveConfig)
|
|
ClientCfg.ConfigFile.save();
|
|
}
|
|
|
|
|
|
/*
|
|
static volatile bool isMainlandCharacter = false; // TMP until we can get this info
|
|
if (isMainlandCharacter)
|
|
{
|
|
nlassert(0); // use id="message_box" !!!
|
|
if (AvailablePatchs != 0)
|
|
{
|
|
im->messageBoxWithHelp(CI18N::get("uiBGD_MainlandCharFullPatchNeeded"), "ui:outgame");
|
|
}
|
|
return;
|
|
}
|
|
*/
|
|
|
|
|
|
// Select the right sheet to create the user character.
|
|
ClientCfg.UserSheet = CharacterSummaries[PlayerSelectedSlot].SheetId.toString();
|
|
|
|
// If the user wants to enter its editing session, get the ring server to Far TP to.
|
|
if (wantsEditMode)
|
|
{
|
|
|
|
if (wantsNewScenario)
|
|
{
|
|
CSessionBrowserImpl &sb = CSessionBrowserImpl::getInstance();
|
|
sb.init(NULL);
|
|
sb.closeEditSession(sb.getCharId());
|
|
sb.waitOneMessage(CSessionBrowserImpl::getMessageName("on_invokeResult"));
|
|
}
|
|
if (FarTP.requestFarTPToSession( (TSessionId)0, PlayerSelectedSlot, CFarTP::LaunchEditor, false ))
|
|
{
|
|
WaitServerAnswer = true; // prepare to receive the character messages
|
|
}
|
|
|
|
// // If the player clicked 'Launch Editor', there was no CONNECTION:SELECT_CHAR sent yet,
|
|
// // so don't wait for the EGS to acknowledge our quit message as he does not know our character
|
|
// LoginSM.pushEvent(CLoginStateMachine::ev_ingame_return);
|
|
|
|
return;
|
|
}
|
|
|
|
// Send CONNECTION:SELECT_CHAR
|
|
CBitMemStream out;
|
|
nlverify( GenericMsgHeaderMngr.pushNameToStream ("CONNECTION:SELECT_CHAR", out) );
|
|
//nlinfo("impulseCallBack : CONNECTION:SELECT_CHAR '%d' sent.", PlayerSelectedSlot);
|
|
|
|
|
|
CSelectCharMsg SelectCharMsg;
|
|
SelectCharMsg.c = (uint8)PlayerSelectedSlot;
|
|
out.serial (SelectCharMsg);
|
|
if (!ClientCfg.Local/*ace!ClientCfg.Light*/)
|
|
{
|
|
NetMngr.push(out);
|
|
NetMngr.send(NetMngr.getCurrentServerTick());
|
|
}
|
|
|
|
//PlayerWantToGoInGame = true;
|
|
|
|
// CBitMemStream out2;
|
|
// if(GenericMsgHeaderMngr.pushNameToStream("CONNECTION:ENTER", out2))
|
|
// {
|
|
// NetMngr.push(out2);
|
|
// nlinfo("impulseCallBack : CONNECTION:ENTER sent");
|
|
// }
|
|
// else
|
|
// nlwarning("unknown message name : 'CONNECTION:ENTER'.");
|
|
|
|
WaitServerAnswer = true;
|
|
if (ClientCfg.Local)
|
|
serverReceivedReady = true;
|
|
}
|
|
};
|
|
REGISTER_ACTION_HANDLER (CAHLaunchGame, "launch_game");
|
|
|
|
|
|
// Ask the server to create a character
|
|
// ------------------------------------------------------------------------------------------------
|
|
class CAHAskCreateChar : public IActionHandler
|
|
{
|
|
public:
|
|
virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
|
|
{
|
|
CInterfaceManager *pIM = CInterfaceManager::getInstance();
|
|
|
|
// Create the message for the server to create the character.
|
|
CBitMemStream out;
|
|
if (!GenericMsgHeaderMngr.pushNameToStream("CONNECTION:CREATE_CHAR", out))
|
|
{
|
|
nlwarning ("don't know message name CONNECTION:CREATE_CHAR");
|
|
return;
|
|
}
|
|
|
|
// Setup the name
|
|
string sEditBoxPath = getParam (Params, "name");
|
|
ucstring sFirstName = ucstring("NotSet");
|
|
ucstring sSurName = ucstring("NotSet");
|
|
CGroupEditBox *pGEB = dynamic_cast<CGroupEditBox*>(pIM->getElementFromId(sEditBoxPath));
|
|
if (pGEB != NULL)
|
|
sFirstName = pGEB->getInputString();
|
|
else
|
|
nlwarning ("can't get edit box name : %s",sEditBoxPath.c_str());
|
|
|
|
// Build the character summary from the database branch ui:temp:char3d
|
|
CCharacterSummary CS;
|
|
string sCharSumPath = getParam(Params, "charsum");
|
|
SCharacter3DSetup::setupCharacterSummaryFromDB(CS, sCharSumPath);
|
|
CS.Mainland = MainlandSelected;
|
|
CS.Name = sFirstName;
|
|
//CS.Surname = sSurName;
|
|
|
|
// Create the message to send to the server from the character summary
|
|
CCreateCharMsg CreateCharMsg;
|
|
|
|
CreateCharMsg.setupFromCharacterSummary(CS);
|
|
|
|
// Slot
|
|
{
|
|
string sSlot = getParam(Params, "slot");
|
|
|
|
CInterfaceExprValue result;
|
|
if (!CInterfaceExpr::eval(sSlot, result))
|
|
return;
|
|
|
|
CreateCharMsg.Slot = (uint8)result.getInteger();
|
|
|
|
pIM->getDbProp("UI:SELECTED_SLOT")->setValue32(PlayerSelectedSlot);
|
|
}
|
|
|
|
// Setup the new career
|
|
string sCaracBasePath = getParam (Params, "caracs");
|
|
CreateCharMsg.NbPointFighter = (uint8)pIM->getDbProp(sCaracBasePath+"FIGHT")->getValue32();
|
|
CreateCharMsg.NbPointCaster = (uint8)pIM->getDbProp(sCaracBasePath+"MAGIC")->getValue32();
|
|
CreateCharMsg.NbPointCrafter = (uint8)pIM->getDbProp(sCaracBasePath+"CRAFT")->getValue32();
|
|
CreateCharMsg.NbPointHarvester = (uint8)pIM->getDbProp(sCaracBasePath+"FORAGE")->getValue32();
|
|
|
|
// Setup starting point
|
|
string sLocationPath = getParam(Params, "loc");
|
|
{
|
|
CreateCharMsg.StartPoint = RYZOM_STARTING_POINT::borea;
|
|
|
|
CCDBNodeLeaf *pNL = pIM->getDbProp (sLocationPath, false);
|
|
if (pNL != NULL)
|
|
CreateCharMsg.StartPoint = (RYZOM_STARTING_POINT::TStartPoint)(pNL->getValue64());
|
|
else
|
|
nlwarning(("Can't read starting point from the database : " + sLocationPath).c_str());
|
|
|
|
if (CS.People == EGSPD::CPeople::Fyros)
|
|
CreateCharMsg.StartPoint= (RYZOM_STARTING_POINT::TStartPoint)(((uint8)CreateCharMsg.StartPoint) + ((uint8)RYZOM_STARTING_POINT::fyros_start));
|
|
else if (CS.People == EGSPD::CPeople::Matis)
|
|
CreateCharMsg.StartPoint= (RYZOM_STARTING_POINT::TStartPoint)(((uint8)CreateCharMsg.StartPoint) + ((uint8)RYZOM_STARTING_POINT::matis_start));
|
|
else if (CS.People == EGSPD::CPeople::Tryker)
|
|
CreateCharMsg.StartPoint= (RYZOM_STARTING_POINT::TStartPoint)(((uint8)CreateCharMsg.StartPoint) + ((uint8)RYZOM_STARTING_POINT::tryker_start));
|
|
else // if (CS.People == EGSPD::CPeople::Zorai)
|
|
CreateCharMsg.StartPoint= (RYZOM_STARTING_POINT::TStartPoint)(((uint8)CreateCharMsg.StartPoint) + ((uint8)RYZOM_STARTING_POINT::zorai_start));
|
|
|
|
}
|
|
|
|
// Send the message to the server
|
|
CreateCharMsg.serialBitMemStream (out);
|
|
if (!ClientCfg.Local/*!ClientCfg.Light*/)
|
|
{
|
|
noUserChar = userChar = false;
|
|
|
|
NetMngr.push(out);
|
|
NetMngr.send(NetMngr.getCurrentServerTick());
|
|
|
|
//nlinfo("impulseCallBack : CONNECTION:CREATE_CHAR sent");
|
|
CreateCharMsg.dump();
|
|
}
|
|
else
|
|
{
|
|
userChar = true;
|
|
if (CharacterSummaries.size() < 5)
|
|
CharacterSummaries.push_back(CS);
|
|
}
|
|
WaitServerAnswer = true;
|
|
}
|
|
};
|
|
REGISTER_ACTION_HANDLER (CAHAskCreateChar, "ask_create_char");
|
|
|
|
|
|
|
|
// Ask the server to delete a character
|
|
// ------------------------------------------------------------------------------------------------
|
|
class CAHAskDeleteChar : public IActionHandler
|
|
{
|
|
public:
|
|
virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
|
|
{
|
|
// Create the message for the server to create the character.
|
|
CBitMemStream out;
|
|
if (!GenericMsgHeaderMngr.pushNameToStream("CONNECTION:DELETE_CHAR", out))
|
|
{
|
|
nlwarning ("don't know message name CONNECTION:DELETE_CHAR");
|
|
return;
|
|
}
|
|
|
|
// Get the selected slot
|
|
CInterfaceManager *pIM = CInterfaceManager::getInstance();
|
|
|
|
string sSlot = getParam(Params, "slot");
|
|
|
|
CInterfaceExprValue result;
|
|
if (!CInterfaceExpr::eval(sSlot, result))
|
|
return;
|
|
|
|
uint8 nSelectedSlot = (uint8)result.getInteger();
|
|
if (nSelectedSlot >= CharacterSummaries.size())
|
|
return;
|
|
|
|
out.serial (nSelectedSlot);
|
|
|
|
// Yoyo: delete the Local files. To avoid problem if recreate a character with same name.
|
|
ucstring &playerName= CharacterSummaries[nSelectedSlot].Name;
|
|
string playerDeletedFileName= buildPlayerNameForSaveFile(playerName);
|
|
// Delete the 2 Local files
|
|
pIM->deletePlayerConfig(playerDeletedFileName);
|
|
pIM->deletePlayerKeys(playerDeletedFileName);
|
|
|
|
// Send the message to the server
|
|
if (!ClientCfg.Local/*ace!ClientCfg.Light*/)
|
|
{
|
|
noUserChar = userChar = false;
|
|
NetMngr.push(out);
|
|
NetMngr.send(NetMngr.getCurrentServerTick());
|
|
|
|
//nlinfo("impulseCallBack : CONNECTION:DELETE_CHAR %d sent", nSelectedSlot);
|
|
}
|
|
else
|
|
{
|
|
if (nSelectedSlot < CharacterSummaries.size())
|
|
CharacterSummaries.erase (CharacterSummaries.begin()+nSelectedSlot);
|
|
if (CharacterSummaries.size() != 0)
|
|
userChar = true;
|
|
else
|
|
noUserChar = true;
|
|
}
|
|
WaitServerAnswer = true;
|
|
}
|
|
};
|
|
REGISTER_ACTION_HANDLER (CAHAskDeleteChar, "ask_delete_char");
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
string getTarget(CCtrlBase * /* ctrl */, const string &targetName)
|
|
{
|
|
string sTmp = targetName;
|
|
std::vector<CInterfaceLink::CTargetInfo> targetsVector;
|
|
CInterfaceParser::splitLinkTargets(sTmp, NULL, targetsVector);
|
|
|
|
CInterfaceLink::CTargetInfo &rTI = targetsVector[0];
|
|
|
|
CInterfaceElement *elem = rTI.Elem;
|
|
if (!elem)
|
|
{
|
|
nlwarning("<CInterfaceExpr::getprop> : Element is NULL");
|
|
return "";
|
|
}
|
|
const CReflectedProperty *pRP = CReflectSystem ::getProperty(elem->getReflectedClassName(), rTI.PropertyName);
|
|
|
|
if (pRP->Type == CReflectedProperty::String)
|
|
return ((elem->*(pRP->GetMethod.GetString))());
|
|
return "";
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
ucstring getUCTarget(CCtrlBase * /* ctrl */, const string &targetName)
|
|
{
|
|
string sTmp = targetName;
|
|
std::vector<CInterfaceLink::CTargetInfo> targetsVector;
|
|
CInterfaceParser::splitLinkTargets(sTmp, NULL, targetsVector);
|
|
|
|
CInterfaceLink::CTargetInfo &rTI = targetsVector[0];
|
|
|
|
CInterfaceElement *elem = rTI.Elem;
|
|
if (!elem)
|
|
{
|
|
nlwarning("<CInterfaceExpr::getprop> : Element is NULL");
|
|
return ucstring("");
|
|
}
|
|
const CReflectedProperty *pRP = elem->getReflectedProperty(rTI.PropertyName);
|
|
|
|
if (pRP->Type == CReflectedProperty::UCString)
|
|
return ((elem->*(pRP->GetMethod.GetUCString))());
|
|
return ucstring("");
|
|
}
|
|
|
|
/*// Ask the server to rename a character
|
|
// ------------------------------------------------------------------------------------------------
|
|
class CAHAskRenameChar : public IActionHandler
|
|
{
|
|
public:
|
|
virtual void execute (CCtrlBase *pCaller, const string &Params)
|
|
{
|
|
string sName = getTarget(NULL,getParam(Params, "name"));
|
|
string sSurname = getTarget(NULL,getParam(Params, "surname"));
|
|
|
|
string sDBSlot = getParam(Params, "dbslot");
|
|
|
|
CInterfaceManager *pIM = CInterfaceManager::getInstance();
|
|
uint8 nSelectedSlot = (uint8)pIM->getDbProp(sDBSlot,false)->getValue32();
|
|
|
|
if (nSelectedSlot > CharacterSummaries.size())
|
|
return;
|
|
|
|
// Create the message for the server to create the character.
|
|
CBitMemStream out;
|
|
if (!GenericMsgHeaderMngr.pushNameToStream("CONNECTION:RENAME_CHAR", out))
|
|
{
|
|
nlwarning ("don't know message name CONNECTION:RENAME_CHAR");
|
|
return;
|
|
}
|
|
|
|
// Get the selected slot
|
|
out.serial (nSelectedSlot);
|
|
out.serial (sName);
|
|
out.serial (sSurname);
|
|
|
|
// Send the message to the server
|
|
if (!ClientCfg.Light)
|
|
{
|
|
noUserChar = userChar = false;
|
|
NetMngr.push (out);
|
|
NetMngr.send (NetMngr.getCurrentServerTick());
|
|
|
|
nldebug("impulseCallBack : CONNECTION:RENAME_CHAR sent");
|
|
|
|
// Wait for the character message which describe all the characters on a server
|
|
while (!noUserChar && !userChar)
|
|
{
|
|
//NetMngr.waitForServer();
|
|
NetMngr.update();
|
|
NetMngr.send();
|
|
nlSleep(100);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CharacterSummaries[nSelectedSlot].FirstName = sName;
|
|
CharacterSummaries[nSelectedSlot].Surname = sSurname;
|
|
}
|
|
}
|
|
};
|
|
REGISTER_ACTION_HANDLER (CAHAskRenameChar, "ask_rename_char");
|
|
*/
|
|
|
|
// Ask the server if the name is not already used
|
|
// ------------------------------------------------------------------------------------------------
|
|
class CAHAskValidName : public IActionHandler
|
|
{
|
|
public:
|
|
virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
|
|
{
|
|
string sTarget = getParam(Params, "target");
|
|
string sDBLink = getParam(Params, "dblink");
|
|
CharNameValidDBLink = sDBLink;
|
|
|
|
ucstring sName = getUCTarget(NULL,sTarget);
|
|
|
|
CInterfaceManager *pIM = CInterfaceManager::getInstance();
|
|
if (sName.empty())
|
|
{
|
|
pIM->getDbProp(sDBLink,false)->setValue32(0);
|
|
return;
|
|
}
|
|
|
|
// Ask the server
|
|
CharNameValid = true;
|
|
|
|
// PATCH DU BUG DE L'ESPACE !!!
|
|
if (sName.find(' ') != ucstring::npos)
|
|
CharNameValid = false;
|
|
// PATCH DU BUG DE L'ESPACE !!!
|
|
|
|
|
|
if (CharNameValid)
|
|
{
|
|
if (!ClientCfg.Local/*ace!ClientCfg.Light*/)
|
|
{
|
|
|
|
CBitMemStream out;
|
|
if (!GenericMsgHeaderMngr.pushNameToStream("CONNECTION:ASK_NAME", out))
|
|
{
|
|
nlwarning ("don't know message name CONNECTION:ASK_NAME");
|
|
return;
|
|
}
|
|
|
|
CCheckNameMsg checkNameMsg;
|
|
checkNameMsg.Name = sName;
|
|
checkNameMsg.HomeSessionId = MainlandSelected;
|
|
checkNameMsg.serialBitMemStream(out);
|
|
|
|
NewKeysCharNameWanted = sName;
|
|
// append shard name
|
|
for(uint k = 0; k < Mainlands.size(); ++k)
|
|
{
|
|
if (Mainlands[k].Id == MainlandSelected)
|
|
{
|
|
// extract name from mainland
|
|
/*ucstring::size_type first = Mainlands[k].Name.find('(');
|
|
ucstring::size_type last = Mainlands[k].Name.find(')');
|
|
if (first != ucstring::npos && last != ucstring::npos && first < last)
|
|
{
|
|
NewKeysCharNameWanted += Mainlands[k].Name.substr(first, last - first + 1);
|
|
}*/
|
|
NewKeysCharNameWanted += ('(' + Mainlands[k].Name + ')');
|
|
break;
|
|
}
|
|
}
|
|
|
|
NewKeysCharNameValidated = "";
|
|
|
|
NetMngr.push(out);
|
|
NetMngr.send(NetMngr.getCurrentServerTick());
|
|
|
|
//nlinfo("impulseCallBack : CONNECTION:ASK_NAME sent");
|
|
|
|
// Wait for the valid character name message
|
|
CharNameValidArrived = false;
|
|
}
|
|
else
|
|
{
|
|
|
|
CharNameValid = true;
|
|
CharNameValidArrived = true;
|
|
|
|
for (uint i = 0; i < CharacterSummaries.size(); ++i)
|
|
{
|
|
ucstring ls = CharacterSummaries[i].Name.toString();
|
|
if (ls == sName)
|
|
CharNameValid = false;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CharNameValidArrived = true;
|
|
}
|
|
WaitServerAnswer = true;
|
|
}
|
|
};
|
|
REGISTER_ACTION_HANDLER (CAHAskValidName, "ask_valid_name");
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
class CAHPlaySound : public IActionHandler
|
|
{
|
|
public:
|
|
virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
|
|
{
|
|
string sName = getParam(Params, "name");
|
|
TStringId id = CStringMapper::map(sName);
|
|
if (SoundMngr != NULL)
|
|
SoundMngr->spawnSource(id,CVector(0,0,0));
|
|
}
|
|
};
|
|
REGISTER_ACTION_HANDLER (CAHPlaySound, "play_sound");
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
class CAHPlayMusicOutgame : public IActionHandler
|
|
{
|
|
public:
|
|
virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
|
|
{
|
|
// get the name of the wanted music
|
|
string sName = getParam(Params, "name");
|
|
bool async;
|
|
fromString(getParam(Params, "async"), async);
|
|
|
|
// if empty name, return to default mode
|
|
if(sName.empty())
|
|
sName= ClientCfg.SoundOutGameMusic;
|
|
|
|
// change the music
|
|
SoundGlobalMenu.setMusic(sName, async);
|
|
}
|
|
};
|
|
REGISTER_ACTION_HANDLER (CAHPlayMusicOutgame, "play_music_outgame");
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
class CAHRepeatUntil : public IActionHandler
|
|
{
|
|
public:
|
|
virtual void execute (CCtrlBase *pCaller, const string &Params)
|
|
{
|
|
string sProc = getParam(Params, "proc");
|
|
string sCond = getParam(Params, "cond");
|
|
CInterfaceManager *pIM = CInterfaceManager::getInstance();
|
|
|
|
for(;;)
|
|
{
|
|
vector<string> p;
|
|
p.push_back(sProc);
|
|
pIM->runProcedure(sProc, pCaller, p);
|
|
|
|
CInterfaceExprValue result;
|
|
if (CInterfaceExpr::eval(sCond, result))
|
|
{
|
|
if (result.getBool())
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
};
|
|
REGISTER_ACTION_HANDLER (CAHRepeatUntil, "repeatuntil");
|
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
class CAHDispInfo : public IActionHandler
|
|
{
|
|
public:
|
|
virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
|
|
{
|
|
string sStr = getParam(Params, "str");
|
|
string sVal = getParam(Params, "val");
|
|
|
|
string res;
|
|
|
|
CInterfaceExprValue result;
|
|
if (CInterfaceExpr::eval(sStr, result))
|
|
{
|
|
if (result.toString())
|
|
{
|
|
res += result.getString();
|
|
}
|
|
}
|
|
if (CInterfaceExpr::eval(sVal, result))
|
|
{
|
|
if (result.toString())
|
|
{
|
|
res += result.getString();
|
|
}
|
|
}
|
|
|
|
nlinfo(res.c_str());
|
|
}
|
|
};
|
|
REGISTER_ACTION_HANDLER (CAHDispInfo, "disp_info");
|
|
|
|
|
|
// ***************************************************************************
|
|
class CAHInitMainlandList : public IActionHandler
|
|
{
|
|
public:
|
|
|
|
virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
|
|
{
|
|
CInterfaceManager *pIM = CInterfaceManager::getInstance();
|
|
|
|
CInterfaceGroup *pList = dynamic_cast<CInterfaceGroup*>(pIM->getElementFromId(GROUP_LIST_MAINLAND));
|
|
if (pList == NULL)
|
|
{
|
|
nlwarning("element "GROUP_LIST_MAINLAND" not found probably bad outgame.xml");
|
|
return;
|
|
}
|
|
|
|
CInterfaceGroup *pPrevLine = NULL;
|
|
for(uint i = 0; i < Mainlands.size(); i++)
|
|
{
|
|
vector< pair < string, string > > params;
|
|
params.clear();
|
|
params.push_back(pair<string,string>("id", toString(Mainlands[i].Id)));
|
|
if (i>0)
|
|
params.push_back(pair<string,string>("posref", "BL TL"));
|
|
|
|
CInterfaceGroup *pNewLine =pIM->createGroupInstance("t_mainland", GROUP_LIST_MAINLAND, params);
|
|
if (pNewLine != NULL)
|
|
{
|
|
CViewBase *pVBon = pNewLine->getView("online");
|
|
CViewBase *pVBoff = pNewLine->getView("offline");
|
|
if ((pVBon != NULL) && (pVBoff != NULL))
|
|
{
|
|
pVBon->setActive(Mainlands[i].Online);
|
|
pVBoff->setActive(!Mainlands[i].Online);
|
|
}
|
|
|
|
CViewText *pVT = dynamic_cast<CViewText*>(pNewLine->getView("name"));
|
|
if (pVT != NULL)
|
|
{
|
|
ucstring ucstr = Mainlands[i].Name + ucstring(" ") + Mainlands[i].Description;
|
|
pVT->setText(ucstr);
|
|
}
|
|
|
|
// Add to the list
|
|
pNewLine->setParent(pList);
|
|
pNewLine->setParentSize(pList);
|
|
pNewLine->setParentPos(pPrevLine);
|
|
pList->addGroup(pNewLine);
|
|
|
|
pPrevLine = pNewLine;
|
|
}
|
|
}
|
|
// UI Patch
|
|
if (!Mainlands.empty())
|
|
{
|
|
//choose default mainland from language code
|
|
uint32 defaultMainland = 0;
|
|
for(uint i = 0; i < Mainlands.size(); i++)
|
|
{
|
|
if( Mainlands[i].LanguageCode == ClientCfg.LanguageCode )
|
|
{
|
|
defaultMainland = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
CCtrlButton *pCB = dynamic_cast<CCtrlButton*>(pIM->getElementFromId(GROUP_LIST_MAINLAND ":"+toString(Mainlands[defaultMainland].Id)+":but"));
|
|
if (pCB != NULL)
|
|
{
|
|
pCB->setPushed(true);
|
|
pIM->runActionHandler (pCB->getActionOnLeftClick(), pCB, pCB->getParamsOnLeftClick());
|
|
}
|
|
}
|
|
pList->invalidateCoords();
|
|
}
|
|
};
|
|
REGISTER_ACTION_HANDLER (CAHInitMainlandList, "init_mainland_list");
|
|
|
|
|
|
// ***************************************************************************
|
|
class CAHResetMainlandList : public IActionHandler
|
|
{
|
|
public:
|
|
|
|
virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
|
|
{
|
|
CInterfaceManager *pIM = CInterfaceManager::getInstance();
|
|
CInterfaceGroup *pList = dynamic_cast<CInterfaceGroup*>(pIM->getElementFromId(GROUP_LIST_MAINLAND));
|
|
pList->clearGroups();
|
|
}
|
|
};
|
|
REGISTER_ACTION_HANDLER (CAHResetMainlandList, "reset_mainland_list");
|
|
|
|
|
|
// ***************************************************************************
|
|
class CAHMainlandSelect : public IActionHandler
|
|
{
|
|
virtual void execute (CCtrlBase *pCaller, const string &/* Params */)
|
|
{
|
|
nlinfo("CAHMainlandSelect called");
|
|
|
|
CInterfaceManager *pIM = CInterfaceManager::getInstance();
|
|
|
|
CCtrlButton *pCB = NULL;
|
|
// Unselect
|
|
if (MainlandSelected.asInt() != 0)
|
|
{
|
|
pCB = dynamic_cast<CCtrlButton*>(pIM->getElementFromId(GROUP_LIST_MAINLAND ":"+toString(MainlandSelected)+":but"));
|
|
if (pCB != NULL)
|
|
pCB->setPushed(false);
|
|
}
|
|
|
|
pCB = dynamic_cast<CCtrlButton*>(pCaller);
|
|
if (pCB != NULL)
|
|
{
|
|
string name = pCB->getId();
|
|
name = name.substr(0,name.rfind(':'));
|
|
uint32 mainland;
|
|
fromString(name.substr(name.rfind(':')+1,name.size()), mainland);
|
|
MainlandSelected = (TSessionId)mainland;
|
|
|
|
pCB->setPushed(true);
|
|
}
|
|
}
|
|
};
|
|
REGISTER_ACTION_HANDLER (CAHMainlandSelect, "mainland_select");
|
|
|
|
|
|
// ***************************************************************************
|
|
class CAHInitKeysetList : public IActionHandler
|
|
{
|
|
public:
|
|
|
|
|
|
|
|
CInterfaceGroup *PrevLine;
|
|
CInterfaceGroup *List;
|
|
bool First;
|
|
|
|
CInterfaceGroup *buildTemplate(const std::string &templateName, const std::string &id)
|
|
{
|
|
vector< pair < string, string > > params;
|
|
params.clear();
|
|
params.push_back(pair<string,string>("id", id));
|
|
if (!First)
|
|
{
|
|
params.push_back(pair<string,string>("posref", "BL TL"));
|
|
}
|
|
First = false;
|
|
CInterfaceManager *pIM = CInterfaceManager::getInstance();
|
|
return pIM->createGroupInstance(templateName, GROUP_LIST_KEYSET, params);
|
|
}
|
|
|
|
void addGroupInList(CInterfaceGroup *pNewLine)
|
|
{
|
|
if (!pNewLine) return;
|
|
// Add to the list
|
|
pNewLine->setParent(List);
|
|
pNewLine->setParentSize(List);
|
|
pNewLine->setParentPos(PrevLine);
|
|
List->addGroup(pNewLine);
|
|
|
|
PrevLine = pNewLine;
|
|
}
|
|
|
|
void addSeparator()
|
|
{
|
|
addGroupInList(buildTemplate("t_keyseparator", ""));
|
|
}
|
|
|
|
// add a new keyset in the list
|
|
void addKeySet(const std::string &filename, const ucstring &name, const ucstring tooltip)
|
|
{
|
|
nlassert(List);
|
|
CInterfaceGroup *pNewLine = buildTemplate("t_keyset", toString(filename));
|
|
if (pNewLine != NULL)
|
|
{
|
|
CViewText *pVT = dynamic_cast<CViewText*>(pNewLine->getView("name"));
|
|
if (pVT != NULL)
|
|
{
|
|
pVT->setText(name);
|
|
}
|
|
|
|
CCtrlBase *pBut = pNewLine->getCtrl("but");
|
|
if (pBut != NULL)
|
|
{
|
|
pBut->setDefaultContextHelp(tooltip);
|
|
}
|
|
addGroupInList(pNewLine);
|
|
}
|
|
}
|
|
|
|
virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
|
|
{
|
|
NewKeysCharNameWanted = "";
|
|
NewKeysCharNameValidated = "";
|
|
GameKeySet = "keys.xml";
|
|
RingEditorKeySet = "keys_r2ed.xml";
|
|
First = true;
|
|
PrevLine = NULL;
|
|
CInterfaceManager *pIM = CInterfaceManager::getInstance();
|
|
|
|
List = dynamic_cast<CInterfaceGroup *>(pIM->getElementFromId(GROUP_LIST_KEYSET));
|
|
if (List == NULL)
|
|
{
|
|
nlwarning("element "GROUP_LIST_KEYSET" not found probably bad outgame.xml");
|
|
return;
|
|
}
|
|
|
|
// built-in keysets
|
|
CConfigFile::CVar *keySetVar = ClientCfg.ConfigFile.getVarPtr(KeySetVarName);
|
|
sint wasdIndex = -1;
|
|
sint zqsdIndex = -1;
|
|
if (keySetVar && keySetVar->size() != 0)
|
|
{
|
|
for (uint k = 0; k < keySetVar->size(); ++k)
|
|
{
|
|
if (keySetVar->asString(k) == "zqsd") zqsdIndex = (sint) k;
|
|
if (keySetVar->asString(k) == "wasd") wasdIndex = (sint) k;
|
|
|
|
std::string strId = "uiCP_KeysetName_" + keySetVar->asString(k);
|
|
strFindReplace(strId, ".", "_");
|
|
ucstring keySetName = CI18N::get(strId);
|
|
strId = "uiCP_KeysetTooltip_" + keySetVar->asString(k);
|
|
strFindReplace(strId, ".", "_");
|
|
if (CI18N::hasTranslation(strId))
|
|
{
|
|
ucstring keySetTooltip = CI18N::get(strId);
|
|
addKeySet(keySetVar->asString(k), keySetName, keySetTooltip);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
nlwarning("'%s' var not found in config file, or list is empty, proposing default keyset only", KeySetVarName);
|
|
std::string defaultKeySet = "keys";
|
|
ucstring keySetName = CI18N::get("uiCP_KeysetName_" + defaultKeySet);
|
|
ucstring keySetTooltip = CI18N::get("uiCP_KeysetTooltip_" + defaultKeySet);
|
|
addKeySet(defaultKeySet, keySetName, keySetTooltip);
|
|
}
|
|
|
|
// keyset from previous chars
|
|
std::vector<std::string> savedFiles;
|
|
CPath::getPathContent("save/", false, false, true, savedFiles);
|
|
enum { GameKeys = 0x1, EditorKeys = 0x2 };
|
|
typedef std::map<std::string, uint> TKeySetFileMap;
|
|
TKeySetFileMap keySetFiles; // combination of 'GameKeys' & 'EditorKeys' flag for each character
|
|
for (uint k = 0; k < savedFiles.size(); ++k)
|
|
{
|
|
if (testWildCard(CFile::getFilename(savedFiles[k]), "keys_*.xml"))
|
|
{
|
|
bool editorKeys = testWildCard(CFile::getFilename(savedFiles[k]), "keys_r2ed_*.xml");
|
|
std::string baseName = CFile::getFilenameWithoutExtension(savedFiles[k]).substr(strlen(editorKeys ? "keys_r2ed_" : "keys_"));
|
|
if(!keySetFiles.count(baseName)) keySetFiles[baseName] = 0;
|
|
keySetFiles[baseName] |= editorKeys ? EditorKeys : GameKeys;
|
|
}
|
|
}
|
|
//
|
|
bool separatorAdded = false;
|
|
if (!keySetFiles.empty())
|
|
{
|
|
for(TKeySetFileMap::iterator it = keySetFiles.begin(); it != keySetFiles.end(); ++it)
|
|
{
|
|
ucstring name;
|
|
if (ClientCfg.Local)
|
|
{
|
|
name = ucstring(it->first);
|
|
}
|
|
else
|
|
{
|
|
// search matching ucstring name from character summaries
|
|
for (uint k = 0; k < CharacterSummaries.size(); ++k)
|
|
{
|
|
if (it->first == buildPlayerNameForSaveFile(CharacterSummaries[k].Name))
|
|
{
|
|
name = CharacterSummaries[k].Name;
|
|
}
|
|
}
|
|
}
|
|
if (!name.empty())
|
|
{
|
|
if (!separatorAdded)
|
|
{
|
|
addSeparator();
|
|
separatorAdded = true;
|
|
}
|
|
addKeySet(it->first, ucstring(it->first), CI18N::get(std::string("uiCP_KeysetImport") + (it->second & GameKeys ? "_Game" : "")
|
|
+ (it->second & EditorKeys ? "_Editor" : "")));
|
|
}
|
|
}
|
|
}
|
|
|
|
// default to 'ZQSD' for French and Belgian keyboard, 'WASD' else
|
|
bool wasd = !CSystemUtils::isAzertyKeyboard();
|
|
|
|
/*sint startIndex = wasd ? wasdIndex : zqsdIndex;
|
|
if (startIndex == -1) startIndex = 0;
|
|
*/
|
|
// TMP TMP : no way to have 2 keys for the same action for now -> default to 'arrows' setting.
|
|
sint startIndex = 0;
|
|
nlassert(startIndex >= 0);
|
|
if (startIndex < (sint) List->getNumGroup())
|
|
{
|
|
CInterfaceGroup *gr = dynamic_cast<CInterfaceGroup *>(List->getGroup(startIndex));
|
|
if (gr)
|
|
{
|
|
CCtrlButton *pCB = dynamic_cast<CCtrlButton*>(gr->getCtrl("but"));
|
|
if (pCB != NULL)
|
|
{
|
|
pCB->setPushed(true);
|
|
pIM->runActionHandler (pCB->getActionOnLeftClick(), pCB, pCB->getParamsOnLeftClick());
|
|
}
|
|
}
|
|
}
|
|
List->invalidateCoords();
|
|
}
|
|
};
|
|
REGISTER_ACTION_HANDLER (CAHInitKeysetList, "init_keyset_list");
|
|
|
|
|
|
// ***************************************************************************
|
|
class CAHResetKeysetList : public IActionHandler
|
|
{
|
|
public:
|
|
|
|
virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
|
|
{
|
|
CInterfaceManager *pIM = CInterfaceManager::getInstance();
|
|
CInterfaceGroup *pList = dynamic_cast<CInterfaceGroup*>(pIM->getElementFromId(GROUP_LIST_KEYSET));
|
|
pList->clearGroups();
|
|
}
|
|
};
|
|
REGISTER_ACTION_HANDLER (CAHResetKeysetList, "reset_keyset_list");
|
|
|
|
|
|
// ***************************************************************************
|
|
class CAHResetKeysetSelect : public IActionHandler
|
|
{
|
|
public:
|
|
std::string getIdPostFix(const std::string fullId)
|
|
{
|
|
std::string::size_type pos = fullId.find_last_of(":");
|
|
if (pos != std::string::npos)
|
|
{
|
|
return fullId.substr(pos + 1);
|
|
}
|
|
return "";
|
|
}
|
|
virtual void execute (CCtrlBase *pCaller, const string &/* Params */)
|
|
{
|
|
if (!pCaller) return;
|
|
// 'unpush' all groups but the caller
|
|
//
|
|
struct CUnpush : public CInterfaceElementVisitor
|
|
{
|
|
CCtrlBase *Ref;
|
|
virtual void visitCtrl(CCtrlBase *ctrl)
|
|
{
|
|
if (ctrl == Ref) return;
|
|
CCtrlBaseButton *but = dynamic_cast<CCtrlBaseButton *>(ctrl);
|
|
if (but)
|
|
{
|
|
but->setPushed(false);
|
|
}
|
|
}
|
|
};
|
|
CInterfaceManager *pIM = CInterfaceManager::getInstance();
|
|
CInterfaceGroup * list = dynamic_cast<CInterfaceGroup *>(pIM->getElementFromId(GROUP_LIST_KEYSET));
|
|
if (list)
|
|
{
|
|
CUnpush unpusher;
|
|
unpusher.Ref = pCaller;
|
|
list->visit(&unpusher);
|
|
}
|
|
CCtrlBaseButton *but = dynamic_cast<CCtrlBaseButton *>(pCaller);
|
|
if (but)
|
|
{
|
|
but->setPushed(true);
|
|
}
|
|
//
|
|
GameKeySet = "keys.xml";
|
|
RingEditorKeySet = "keys_r2ed.xml";
|
|
if (!pCaller->getParent()) return;
|
|
// compute the 2 filenames from the id
|
|
// if id is in the built-in keysets :
|
|
CConfigFile::CVar *keySetVar = ClientCfg.ConfigFile.getVarPtr(KeySetVarName);
|
|
if (keySetVar && keySetVar->size() != 0)
|
|
{
|
|
for (uint k = 0; k < keySetVar->size(); ++k)
|
|
{
|
|
std::string id = getIdPostFix(pCaller->getParent()->getId());
|
|
if (keySetVar->asString(k) == id)
|
|
{
|
|
GameKeySet = "keys" + string(id.empty() ? "" : "_") + id + ".xml";
|
|
RingEditorKeySet = "keys_r2ed" + string(id.empty() ? "" : "_") + id + ".xml";
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
// ... else maybe from a previous character ?
|
|
if (CFile::isExists("save/keys_" + getIdPostFix(pCaller->getParent()->getId()) + ".xml") )
|
|
{
|
|
GameKeySet = "keys_" + getIdPostFix(pCaller->getParent()->getId()) + ".xml";
|
|
}
|
|
if (CFile::isExists("save/keys_r2ed_" + getIdPostFix(pCaller->getParent()->getId()) + ".xml") )
|
|
{
|
|
RingEditorKeySet = "keys_r2ed_" + getIdPostFix(pCaller->getParent()->getId()) + ".xml";
|
|
}
|
|
// NB : key file will be copied for real when the new 'character summary' is
|
|
|
|
}
|
|
};
|
|
REGISTER_ACTION_HANDLER (CAHResetKeysetSelect, "keyset_select");
|
|
|
|
|
|
|
|
|
|
|
|
// *************************** SCENARIO CONTROL WINDOW ***********************
|
|
// ***************************************************************************
|
|
// helper function for "setScenarioInformation"
|
|
static void setTextField(CInterfaceGroup* scenarioWnd, const std::string &uiName, const ucstring &text)
|
|
{
|
|
CInterfaceElement *result = scenarioWnd->findFromShortId(uiName);
|
|
if(result)
|
|
{
|
|
CViewText* viewText = dynamic_cast<CViewText*>(result);
|
|
if(viewText)
|
|
viewText->setText(text);
|
|
CGroupEditBox* editBox = dynamic_cast<CGroupEditBox*>(result);
|
|
if(editBox)
|
|
editBox->setInputString(text);
|
|
|
|
}
|
|
}
|
|
// helper function for "setScenarioInformation"
|
|
static void setTextField(CInterfaceGroup* scenarioWnd, const std::string &uiName, const std::string &utf8Text)
|
|
{
|
|
ucstring ucText;
|
|
ucText.fromUtf8(utf8Text);
|
|
setTextField(scenarioWnd, uiName, ucText);
|
|
}
|
|
// helper function for "setScenarioInformation"
|
|
static std::string fieldLookup(const vector< pair< string, string > > &values, const std::string &id)
|
|
{
|
|
for(uint i=0; i<values.size(); i++)
|
|
{
|
|
if (values[i].first == id) return values[i].second;
|
|
}
|
|
return "--";
|
|
}
|
|
//
|
|
static void setScenarioInformation(CInterfaceGroup* scenarioWnd, const string scenarioName)
|
|
{
|
|
vector< pair< string, string > > values;
|
|
if(R2::getEditor().isInitialized())
|
|
{
|
|
values = R2::getEditor().getDMC().getEditionModule().getScenarioHeader();
|
|
}
|
|
else
|
|
{
|
|
R2::CScenarioValidator sv;
|
|
std::string md5, signature;
|
|
sv.setScenarioToLoad(scenarioName, values, md5, signature, false);
|
|
}
|
|
//
|
|
setTextField(scenarioWnd, "rules_value_text", fieldLookup(values, "Rules"));
|
|
uint levelRange = 0;
|
|
uint32 nLevel;
|
|
fromString(fieldLookup(values, "Level"), nLevel);
|
|
switch(nLevel)
|
|
{
|
|
case 20: levelRange = 0; break;
|
|
case 50: levelRange = 1; break;
|
|
case 100: levelRange = 2; break;
|
|
case 150: levelRange = 3; break;
|
|
case 200: levelRange = 4; break;
|
|
case 250: levelRange = 5; break;
|
|
}
|
|
setTextField(scenarioWnd, "level_value_text", CI18N::get("uiRAP_Level" + toString(levelRange)));
|
|
setTextField(scenarioWnd, "language_value_text", CI18N::get("uiR2ED" + fieldLookup(values, "Language")));
|
|
setTextField(scenarioWnd, "type_value_text", CI18N::get("uiR2ED" + fieldLookup(values, "Type")));
|
|
setTextField(scenarioWnd, "edit_small_description", fieldLookup(values, "ShortDescription"));
|
|
if(R2::getEditor().isInitialized())
|
|
{
|
|
setTextField(scenarioWnd, "scenario_value_text", "'" + fieldLookup(values, "Title") + "'");
|
|
}
|
|
}
|
|
|
|
|
|
void getChildrenControls(CInterfaceGroup* group, std::vector<CCtrlBase*> & controls)
|
|
{
|
|
for(uint i=0; i<group->getGroups().size(); i++)
|
|
getChildrenControls(group->getGroups()[i], controls);
|
|
|
|
for(uint i=0; i<group->getControls().size(); i++)
|
|
controls.push_back(group->getControls()[i]);
|
|
}
|
|
|
|
inline void setToggleButton(CInterfaceGroup* scenarioWnd, const string & buttonName, bool pushed)
|
|
{
|
|
CInterfaceElement * result = scenarioWnd->findFromShortId(buttonName);
|
|
if(result)
|
|
{
|
|
CInterfaceGroup * group = dynamic_cast<CInterfaceGroup*>(result);
|
|
if(group)
|
|
{
|
|
result = group->findFromShortId(string("toggle_butt"));
|
|
if(result)
|
|
{
|
|
CCtrlBaseButton * baseButton = dynamic_cast<CCtrlBaseButton*>(result);
|
|
if(baseButton)
|
|
baseButton->setPushed(!pushed);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
class CAHScenarioControl : public IActionHandler
|
|
{
|
|
virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
|
|
{
|
|
nlinfo("CAHScenarioControl called");
|
|
|
|
CInterfaceManager *pIM = CInterfaceManager::getInstance();
|
|
CInterfaceGroup* scenarioWnd = dynamic_cast<CInterfaceGroup*>(pIM->getElementFromId("ui:interface:r2ed_scenario_control"));
|
|
if(!scenarioWnd) return;
|
|
|
|
// -------- active some groups in function of Ryzom mode or Edition/Animation mode ----
|
|
// active team toggle button?
|
|
CInterfaceElement *result = scenarioWnd->findFromShortId(string("invite_team"));
|
|
if(result)
|
|
{
|
|
CInterfaceGroup* groupTeam = dynamic_cast<CInterfaceGroup*>(result);
|
|
if(groupTeam)
|
|
{
|
|
bool team = !(R2::getEditor().isInitialized());
|
|
if(team)
|
|
team = (pIM->getDbProp("SERVER:USER:TEAM_MEMBER")->getValue8())!=0;
|
|
groupTeam->setActive(team);
|
|
}
|
|
}
|
|
|
|
// set scenario name label
|
|
result = scenarioWnd->findFromShortId(string("current_scenario_label_text"));
|
|
if(result)
|
|
{
|
|
CViewText* viewText = dynamic_cast<CViewText*>(result);
|
|
if(viewText)
|
|
{
|
|
viewText->setText(R2::getEditor().isInitialized()?CI18N::get("uiR2EDScenarioName"):CI18N::get("uiR2EDScenarioFileName"));
|
|
}
|
|
}
|
|
|
|
// ok button tranlation
|
|
result = scenarioWnd->findFromShortId(string("ok_button"));
|
|
if(result)
|
|
{
|
|
CCtrlTextButton* okButton = dynamic_cast<CCtrlTextButton*>(result);
|
|
if(okButton)
|
|
{
|
|
if(R2::getEditor().getAccessMode()!=R2::CEditor::AccessDM)
|
|
okButton->setHardText(CI18N::get("uiR2EDLaunchScenario").toString());
|
|
else
|
|
okButton->setHardText(CI18N::get("uiR2EDApplyScenarioFilters").toString());
|
|
}
|
|
}
|
|
|
|
// init current scenario name and parameters
|
|
if(!R2::getEditor().isInitialized())
|
|
{
|
|
ScenarioFileName = string("");
|
|
|
|
// empty scenario
|
|
CInterfaceElement *result = scenarioWnd->findFromShortId(string("scenario_value_text"));
|
|
if(result)
|
|
{
|
|
CViewText* viewText= dynamic_cast<CViewText*>(result);
|
|
|
|
if(viewText)
|
|
viewText->setText(ucstring(""));
|
|
}
|
|
}
|
|
setScenarioInformation(scenarioWnd, "");
|
|
|
|
// hide description and information?
|
|
result = scenarioWnd->findFromShortId(string("scenario_info_prop"));
|
|
if(result)
|
|
result->setActive(R2::getEditor().isInitialized());
|
|
|
|
result = scenarioWnd->findFromShortId(string("description_gr"));
|
|
if(result)
|
|
result->setActive(R2::getEditor().isInitialized());
|
|
|
|
// mainlands list
|
|
result = scenarioWnd->findFromShortId(string("shards"));
|
|
if(result)
|
|
{
|
|
CGroupList * shardList = dynamic_cast<CGroupList*>(result);
|
|
if(shardList)
|
|
{
|
|
shardList->deleteAllChildren();
|
|
|
|
for(uint i = 0; i < Mainlands.size(); i++)
|
|
{
|
|
vector< pair < string, string > > params;
|
|
params.clear();
|
|
params.push_back(pair<string,string>("id", toString(Mainlands[i].Id)));
|
|
params.push_back(pair<string,string>("w", "1024"));
|
|
params.push_back(pair<string,string>("tooltip", "uiRingFilterShard"));
|
|
CInterfaceGroup *toggleGr =pIM->createGroupInstance("label_toggle_button", shardList->getId(), params);
|
|
shardList->addChild(toggleGr);
|
|
// set unicode name
|
|
CViewText *shardName = dynamic_cast<CViewText *>(toggleGr->getView("button_text"));
|
|
if (shardName)
|
|
{
|
|
shardName->setText(Mainlands[i].Name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// show/display "back" button
|
|
result = scenarioWnd->findFromShortId(string("load_button"));
|
|
if(result)
|
|
{
|
|
CCtrlBaseButton * loadB = dynamic_cast<CCtrlBaseButton *>(result);
|
|
if(loadB)
|
|
{
|
|
loadB->setActive(!R2::getEditor().isInitialized());
|
|
}
|
|
}
|
|
|
|
// fill toggle buttons
|
|
if(R2::getEditor().getAccessMode()==R2::CEditor::AccessDM)
|
|
{
|
|
CSessionBrowserImpl & sessionBrowser = CSessionBrowserImpl::getInstance();
|
|
sessionBrowser.getSessionInfo(sessionBrowser.getCharId(), R2::getEditor().getDMC().getEditionModule().getCurrentAdventureId());
|
|
|
|
if(sessionBrowser.waitOneMessage(sessionBrowser.getMessageName("on_sessionInfoResult")))
|
|
{
|
|
TRaceFilter & raceFilter = sessionBrowser._LastRaceFilter;
|
|
setToggleButton(scenarioWnd, "fyros", raceFilter.checkEnumValue(TRaceFilterEnum::rf_fyros));
|
|
setToggleButton(scenarioWnd, "matis", raceFilter.checkEnumValue(TRaceFilterEnum::rf_matis));
|
|
setToggleButton(scenarioWnd, "tryker", raceFilter.checkEnumValue(TRaceFilterEnum::rf_tryker));
|
|
setToggleButton(scenarioWnd, "zorai", raceFilter.checkEnumValue(TRaceFilterEnum::rf_zorai));
|
|
|
|
TReligionFilter & religionFilter = sessionBrowser._LastReligionFilter;
|
|
setToggleButton(scenarioWnd, "kami", religionFilter.checkEnumValue(TReligionFilterEnum::rf_kami));
|
|
setToggleButton(scenarioWnd, "karavan", religionFilter.checkEnumValue(TReligionFilterEnum::rf_karavan));
|
|
setToggleButton(scenarioWnd, "neutral", religionFilter.checkEnumValue(TReligionFilterEnum::rf_neutral));
|
|
|
|
TGuildFilter & guildFilter = sessionBrowser._LastGuildFilter;
|
|
setToggleButton(scenarioWnd, "guild_gr", (guildFilter==TGuildFilter::gf_any_player));
|
|
|
|
TShardFilter & shardFilter = sessionBrowser._LastShardFilter;
|
|
for(uint i=0; i<Mainlands.size(); i++)
|
|
setToggleButton(scenarioWnd, toString(Mainlands[i].Id), shardFilter.checkEnumValue((RSMGR::TShardFilterEnum::TValues) (1<<i)));
|
|
|
|
TLevelFilter & levelFilter = sessionBrowser._LastLevelFilter;
|
|
setToggleButton(scenarioWnd, "20", levelFilter.checkEnumValue(TLevelFilterEnum::lf_a));
|
|
setToggleButton(scenarioWnd, "50", levelFilter.checkEnumValue(TLevelFilterEnum::lf_b));
|
|
setToggleButton(scenarioWnd, "100", levelFilter.checkEnumValue(TLevelFilterEnum::lf_c));
|
|
setToggleButton(scenarioWnd, "150", levelFilter.checkEnumValue(TLevelFilterEnum::lf_d));
|
|
setToggleButton(scenarioWnd, "200", levelFilter.checkEnumValue(TLevelFilterEnum::lf_e));
|
|
setToggleButton(scenarioWnd, "250", levelFilter.checkEnumValue(TLevelFilterEnum::lf_f));
|
|
|
|
bool subscriptionClosed = sessionBrowser._LastSubscriptionClosed;
|
|
result = scenarioWnd->findFromShortId(string("global_access_toggle_butt"));
|
|
if(result)
|
|
{
|
|
CCtrlBaseButton * baseButton = dynamic_cast<CCtrlBaseButton*>(result);
|
|
if(baseButton)
|
|
baseButton->setPushed(subscriptionClosed);
|
|
}
|
|
|
|
bool autoInvite = sessionBrowser._LastAutoInvite;
|
|
result = scenarioWnd->findFromShortId(string("auto_invite_toggle_butt"));
|
|
if(result)
|
|
{
|
|
CCtrlBaseButton * baseButton = dynamic_cast<CCtrlBaseButton*>(result);
|
|
if(baseButton)
|
|
baseButton->setPushed(!autoInvite);
|
|
}
|
|
|
|
// description
|
|
string description = sessionBrowser._LastDescription;
|
|
if(description!="")
|
|
{
|
|
result = scenarioWnd->findFromShortId(string("edit_small_description"));
|
|
if(result)
|
|
{
|
|
CGroupEditBox* editBox = dynamic_cast<CGroupEditBox*>(result);
|
|
if(editBox)
|
|
editBox->setInputString(description);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
nlwarning("getSessionInfo callback return false");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
result = scenarioWnd->findFromShortId(string("access_players_filter"));
|
|
if(result)
|
|
{
|
|
CInterfaceGroup* filtersGroup = dynamic_cast<CInterfaceGroup*>(result);
|
|
if(filtersGroup)
|
|
{
|
|
std::vector<CCtrlBase*> controls;
|
|
getChildrenControls(filtersGroup, controls);
|
|
for(uint i=0; i<controls.size(); i++)
|
|
{
|
|
CCtrlBase* control = controls[i];
|
|
CCtrlBaseButton * baseButton = dynamic_cast<CCtrlBaseButton*>(control);
|
|
if(baseButton && (baseButton->getType()==CCtrlBaseButton::ToggleButton))
|
|
baseButton->setPushed(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
REGISTER_ACTION_HANDLER (CAHScenarioControl, "init_scenario_control");
|
|
|
|
|
|
// ***************************************************************************
|
|
class CAHScenarioInformation : public IActionHandler
|
|
{
|
|
virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
|
|
{
|
|
nlinfo("CAHScenarioDescription called");
|
|
|
|
CInterfaceManager *pIM = CInterfaceManager::getInstance();
|
|
CInterfaceGroup* scenarioWnd = dynamic_cast<CInterfaceGroup*>(pIM->getElementFromId("ui:interface:r2ed_scenario_control"));
|
|
if(!scenarioWnd) return;
|
|
|
|
CInterfaceElement *result = scenarioWnd->findFromShortId(string("scenario_value_text"));
|
|
if(result)
|
|
{
|
|
CViewText* viewText= dynamic_cast<CViewText*>(result);
|
|
|
|
if(viewText)
|
|
{
|
|
ScenarioFileName = getParam(Params, "ScenarioName");
|
|
setScenarioInformation(scenarioWnd, ScenarioFileName);
|
|
|
|
string scenarioName = ScenarioFileName;
|
|
string::size_type posScenarioName = 0;
|
|
while(posScenarioName!=string::npos)
|
|
{
|
|
scenarioName = scenarioName.substr(posScenarioName==0?posScenarioName:posScenarioName+1);
|
|
posScenarioName = scenarioName.find('/');
|
|
}
|
|
viewText->setText(scenarioName);
|
|
}
|
|
}
|
|
|
|
// active description and information
|
|
result = scenarioWnd->findFromShortId(string("scenario_info_prop"));
|
|
if(result)
|
|
result->setActive(true);
|
|
|
|
result = scenarioWnd->findFromShortId(string("description_gr"));
|
|
if(result)
|
|
result->setActive(true);
|
|
}
|
|
};
|
|
REGISTER_ACTION_HANDLER (CAHScenarioInformation, "scenario_information");
|
|
|
|
// ***************************************************************************
|
|
class CAHHideCharsFilters : public IActionHandler
|
|
{
|
|
virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
|
|
{
|
|
nlinfo("CAHHideCharsFilters called");
|
|
|
|
CInterfaceManager *pIM = CInterfaceManager::getInstance();
|
|
CInterfaceGroup* scenarioWnd = dynamic_cast<CInterfaceGroup*>(pIM->getElementFromId("ui:interface:r2ed_scenario_control"));
|
|
if(!scenarioWnd) return;
|
|
|
|
bool lookingForPlayers = true;
|
|
CInterfaceElement *result = scenarioWnd->findFromShortId(string("global_access_toggle_butt"));
|
|
if(result)
|
|
{
|
|
CCtrlBaseButton * baseButton = dynamic_cast<CCtrlBaseButton*>(result);
|
|
if(baseButton)
|
|
lookingForPlayers = !baseButton->getPushed(); // warning : on / off textures are inverted !!!
|
|
}
|
|
|
|
result = scenarioWnd->findFromShortId(string("access_body_gr"));
|
|
if(result)
|
|
result->setActive(lookingForPlayers);
|
|
|
|
result = scenarioWnd->findFromShortId(string("sep_global_access"));
|
|
if(result)
|
|
result->setActive(lookingForPlayers);
|
|
|
|
result = scenarioWnd->findFromShortId(string("auto_invite_label"));
|
|
if(result)
|
|
result->setActive(lookingForPlayers);
|
|
|
|
result = scenarioWnd->findFromShortId(string("auto_invite_toggle_butt"));
|
|
if(result)
|
|
result->setActive(lookingForPlayers);
|
|
|
|
result = scenarioWnd->findFromShortId(string("invite_team"));
|
|
if(result)
|
|
{
|
|
bool team = (pIM->getDbProp("SERVER:USER:TEAM_MEMBER")->getValue8())!=0;
|
|
team = (team && !(R2::getEditor().isInitialized()) && lookingForPlayers);
|
|
result->setActive(team);
|
|
}
|
|
}
|
|
};
|
|
REGISTER_ACTION_HANDLER (CAHHideCharsFilters, "hide_chars_filters");
|
|
|
|
// ***************************************************************************
|
|
class CAHLoadScenario : public IActionHandler
|
|
{
|
|
virtual void execute (CCtrlBase *pCaller, const string &/* Params */)
|
|
{
|
|
nlinfo("CAHLoadScenario called");
|
|
|
|
CInterfaceManager *pIM = CInterfaceManager::getInstance();
|
|
CInterfaceGroup* scenarioWnd = dynamic_cast<CInterfaceGroup*>(pIM->getElementFromId("ui:interface:r2ed_scenario_control"));
|
|
if(!scenarioWnd) return;
|
|
|
|
CInterfaceElement *result = NULL;
|
|
|
|
// load scenario
|
|
if(!R2::getEditor().isInitialized())
|
|
{
|
|
R2::CEditor::setStartingAnimationFilename(ScenarioFileName);
|
|
}
|
|
|
|
// description
|
|
string description = string("");
|
|
result = scenarioWnd->findFromShortId(string("edit_small_description"));
|
|
if(result)
|
|
{
|
|
CGroupEditBox* editBox = dynamic_cast<CGroupEditBox*>(result);
|
|
if(editBox)
|
|
description = editBox->getInputString().toString();
|
|
}
|
|
|
|
// races
|
|
map<string, bool> races;
|
|
races["fyros"] = false;
|
|
races["matis"] = false;
|
|
races["tryker"] = false;
|
|
races["zorai"] = false;
|
|
for(map<string, bool>::iterator itRace=races.begin(); itRace!=races.end(); itRace++)
|
|
{
|
|
result = scenarioWnd->findFromShortId(itRace->first);
|
|
if(result)
|
|
{
|
|
CInterfaceGroup * group = dynamic_cast<CInterfaceGroup*>(result);
|
|
if(group)
|
|
{
|
|
result = group->findFromShortId(string("toggle_butt"));
|
|
if(result)
|
|
{
|
|
CCtrlBaseButton * baseButton = dynamic_cast<CCtrlBaseButton*>(result);
|
|
if(baseButton)
|
|
itRace->second = !baseButton->getPushed();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// religion
|
|
map<string, bool> religions;
|
|
religions["kami"] = false;
|
|
religions["karavan"] = false;
|
|
religions["neutral"] = false;
|
|
for(map<string, bool>::iterator itReligion=religions.begin(); itReligion!=religions.end(); itReligion++)
|
|
{
|
|
result = scenarioWnd->findFromShortId(itReligion->first);
|
|
if(result)
|
|
{
|
|
CInterfaceGroup * group = dynamic_cast<CInterfaceGroup*>(result);
|
|
if(group)
|
|
{
|
|
result = group->findFromShortId(string("toggle_butt"));
|
|
if(result)
|
|
{
|
|
CCtrlBaseButton * baseButton = dynamic_cast<CCtrlBaseButton*>(result);
|
|
if(baseButton)
|
|
itReligion->second = !baseButton->getPushed();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// guild
|
|
bool anyPlayer = false;
|
|
result = scenarioWnd->findFromShortId(string("guild_gr"));
|
|
if(result)
|
|
{
|
|
CInterfaceGroup * group = dynamic_cast<CInterfaceGroup*>(result);
|
|
if(group)
|
|
{
|
|
result = group->findFromShortId(string("toggle_butt"));
|
|
if(result)
|
|
{
|
|
CCtrlBaseButton * baseButton = dynamic_cast<CCtrlBaseButton*>(result);
|
|
if(baseButton)
|
|
anyPlayer = !baseButton->getPushed();
|
|
}
|
|
}
|
|
}
|
|
|
|
// shards
|
|
std::vector<bool> shards(Mainlands.size(), false);
|
|
for(uint i=0; i<Mainlands.size(); i++)
|
|
{
|
|
string firstKey = Mainlands[i].Description.toString();
|
|
|
|
result = scenarioWnd->findFromShortId(toString(Mainlands[i].Id));
|
|
if(result)
|
|
{
|
|
CInterfaceGroup * group = dynamic_cast<CInterfaceGroup*>(result);
|
|
if(group)
|
|
{
|
|
result = group->findFromShortId(string("toggle_butt"));
|
|
if(result)
|
|
{
|
|
CCtrlBaseButton * baseButton = dynamic_cast<CCtrlBaseButton*>(result);
|
|
if(baseButton)
|
|
shards[i] = !baseButton->getPushed();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// levels
|
|
map<string, bool> levels;
|
|
levels["20"] = false;
|
|
levels["50"] = false;
|
|
levels["100"] = false;
|
|
levels["150"] = false;
|
|
levels["200"] = false;
|
|
levels["250"] = false;
|
|
for(map<string, bool>::iterator itLevel=levels.begin(); itLevel!=levels.end(); itLevel++)
|
|
{
|
|
result = scenarioWnd->findFromShortId(itLevel->first);
|
|
if(result)
|
|
{
|
|
CInterfaceGroup * group = dynamic_cast<CInterfaceGroup*>(result);
|
|
if(group)
|
|
{
|
|
result = group->findFromShortId(string("toggle_butt"));
|
|
if(result)
|
|
{
|
|
CCtrlBaseButton * baseButton = dynamic_cast<CCtrlBaseButton*>(result);
|
|
if(baseButton)
|
|
itLevel->second = !baseButton->getPushed();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// global access
|
|
bool globalAccess = false;
|
|
result = scenarioWnd->findFromShortId(string("global_access_toggle_butt"));
|
|
if(result)
|
|
{
|
|
CCtrlBaseButton * baseButton = dynamic_cast<CCtrlBaseButton*>(result);
|
|
if(baseButton)
|
|
globalAccess = !baseButton->getPushed();
|
|
}
|
|
|
|
// auto invite
|
|
bool autoInvite = false;
|
|
result = scenarioWnd->findFromShortId(string("auto_invite_toggle_butt"));
|
|
if(result)
|
|
{
|
|
CCtrlBaseButton * baseButton = dynamic_cast<CCtrlBaseButton*>(result);
|
|
if(baseButton)
|
|
autoInvite = !baseButton->getPushed();
|
|
}
|
|
|
|
// invite your team
|
|
bool inviteTeam = false;
|
|
result = scenarioWnd->findFromShortId(string("team_toggle_butt"));
|
|
if(result)
|
|
{
|
|
CCtrlBaseButton * baseButton = dynamic_cast<CCtrlBaseButton*>(result);
|
|
if(baseButton)
|
|
inviteTeam = !baseButton->getPushed();
|
|
}
|
|
|
|
bool launchScenarioFromRingAccessPoint = false;
|
|
|
|
vector< pair< string, string > > values;
|
|
if(R2::getEditor().isInitialized())
|
|
{
|
|
values = R2::getEditor().getDMC().getEditionModule().getScenarioHeader();
|
|
}
|
|
else
|
|
{
|
|
R2::CScenarioValidator sv;
|
|
std::string md5, signature;
|
|
sv.setScenarioToLoad(ScenarioFileName, values, md5, signature, false);
|
|
launchScenarioFromRingAccessPoint = true;
|
|
}
|
|
|
|
string rules="", level="", title="";
|
|
string initialIsland="", initialEntryPoint="", initialSeason = "";
|
|
std::string lang="", scenarioType="";
|
|
std::string otherCharAccess="";
|
|
std::string nevraxScenario = "0";
|
|
std::string trialAllowed = "0";
|
|
for(uint i=0; i<values.size(); i++)
|
|
{
|
|
std::pair<std::string, std::string> pair = values[i];
|
|
|
|
if(pair.first == "Rules") rules = pair.second;
|
|
else if(pair.first == "Level") level = pair.second;
|
|
else if(pair.first == "Title") title = pair.second;
|
|
else if(pair.first == "InitialIsland") initialIsland = pair.second;
|
|
else if(pair.first == "InitialEntryPoint") initialEntryPoint = pair.second;
|
|
else if(pair.first == "InitialSeason") initialSeason = pair.second;
|
|
else if(pair.first == "Language") lang = pair.second;
|
|
else if(pair.first == "Type") scenarioType = pair.second;
|
|
else if(pair.first == "OtherCharAccess") otherCharAccess = pair.second;
|
|
else if(pair.first == "NevraxScenario") nevraxScenario = pair.second;
|
|
else if(pair.first == "TrialAllowed") trialAllowed = pair.second;
|
|
}
|
|
|
|
uint nLevel;
|
|
fromString(level, nLevel);
|
|
R2::TSessionLevel sessionLevel = R2::TSessionLevel::TValues(nLevel/50 + 1);
|
|
|
|
// ---- fix for old scenarii
|
|
if (lang == "French")
|
|
lang = "fr";
|
|
else if (lang == "German" || lang == "Deutsch")
|
|
lang = "de";
|
|
else //if (lang == "English")
|
|
lang = "en";
|
|
|
|
if (nlstricmp(scenarioType, "Roleplay") == 0 || nlstricmp(scenarioType, "Role play") == 0)
|
|
scenarioType = "so_story_telling";
|
|
else if (nlstricmp(scenarioType, "Combat") == 0)
|
|
scenarioType = "so_hack_slash";
|
|
// --------------------------
|
|
|
|
TRuleType ruleType(TRuleType::rt_strict);
|
|
if(rules==CI18N::get("uiR2EDliberal").toString())
|
|
ruleType = TRuleType(TRuleType::rt_liberal);
|
|
else if(rules == CI18N::get("uiR2EDstrict").toString())
|
|
ruleType = TRuleType(TRuleType::rt_strict);
|
|
volatile static bool override = false;
|
|
if (override)
|
|
{
|
|
if(rules== "Masterless")
|
|
ruleType = TRuleType(TRuleType::rt_liberal);
|
|
else if(rules == "Mastered")
|
|
ruleType = TRuleType(TRuleType::rt_strict);
|
|
}
|
|
|
|
TRaceFilter raceFilter;
|
|
if(races["fyros"])
|
|
raceFilter.setEnumValue(TRaceFilterEnum::rf_fyros);
|
|
if(races["matis"])
|
|
raceFilter.setEnumValue(TRaceFilterEnum::rf_matis);
|
|
if(races["tryker"])
|
|
raceFilter.setEnumValue(TRaceFilterEnum::rf_tryker);
|
|
if(races["zorai"])
|
|
raceFilter.setEnumValue(TRaceFilterEnum::rf_zorai);
|
|
|
|
TReligionFilter religionFilter;
|
|
if(religions["kami"])
|
|
religionFilter.setEnumValue(TReligionFilterEnum::rf_kami);
|
|
if(religions["karavan"])
|
|
religionFilter.setEnumValue(TReligionFilterEnum::rf_karavan);
|
|
if(religions["neutral"])
|
|
religionFilter.setEnumValue(TReligionFilterEnum::rf_neutral);
|
|
|
|
TGuildFilter guildFilter(anyPlayer?TGuildFilter::gf_any_player:TGuildFilter::gf_only_my_guild);
|
|
|
|
TShardFilter shardFilter;
|
|
for (uint i = 0; i < shards.size(); ++i)
|
|
{
|
|
if (shards[i]) shardFilter.setEnumValue((RSMGR::TShardFilterEnum::TValues) (1<<i));
|
|
}
|
|
|
|
TLevelFilter levelFilter;
|
|
if(levels["20"])
|
|
levelFilter.setEnumValue(TLevelFilterEnum::lf_a);
|
|
if(levels["50"])
|
|
levelFilter.setEnumValue(TLevelFilterEnum::lf_b);
|
|
if(levels["100"])
|
|
levelFilter.setEnumValue(TLevelFilterEnum::lf_c);
|
|
if(levels["150"])
|
|
levelFilter.setEnumValue(TLevelFilterEnum::lf_d);
|
|
if(levels["200"])
|
|
levelFilter.setEnumValue(TLevelFilterEnum::lf_e);
|
|
if(levels["250"])
|
|
levelFilter.setEnumValue(TLevelFilterEnum::lf_f);
|
|
|
|
uint32 charId = 0;
|
|
if (!ClientCfg.Local)
|
|
charId = (NetMngr.getLoginCookie().getUserId()<< 4) + (uint32) PlayerSelectedSlot;
|
|
|
|
CSessionBrowserImpl & sessionBrowser = CSessionBrowserImpl::getInstance();
|
|
|
|
if(R2::getEditor().getAccessMode() != R2::CEditor::AccessDM)
|
|
{
|
|
bool noob = pIM->getDbProp("SERVER:USER:IS_NEWBIE")->getValueBool();
|
|
if (FreeTrial && noob && (nevraxScenario != "1" || trialAllowed != "1"))
|
|
{
|
|
CViewText* pVT = dynamic_cast<CViewText*>(pIM->getElementFromId("ui:interface:warning_free_trial:text"));
|
|
if (pVT != NULL)
|
|
pVT->setText(CI18N::get("uiRingWarningFreeTrial"));
|
|
pIM->runActionHandler("enter_modal", pCaller, "group=ui:interface:warning_free_trial");
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
if(R2::getEditor().getAccessMode()!=R2::CEditor::AccessDM)
|
|
{
|
|
if (launchScenarioFromRingAccessPoint)
|
|
{
|
|
// hibernate Edit Session if active
|
|
sessionBrowser.hibernateEditSession(charId);
|
|
if(!sessionBrowser.waitOneMessage(sessionBrowser.getMessageName("on_invokeResult")))
|
|
{
|
|
nlwarning("hibernateEditSession callback return false");
|
|
}
|
|
|
|
}
|
|
|
|
// schedule session
|
|
bool launchSuccess = true;
|
|
sessionBrowser.scheduleSession(charId, TSessionType::st_anim,
|
|
title, description, sessionLevel,
|
|
/*TAccessType::at_public,*/ ruleType, TEstimatedDuration::et_medium, 0, TAnimMode::am_dm,
|
|
raceFilter, religionFilter, guildFilter, shardFilter, levelFilter, lang, RSMGR::TSessionOrientation(scenarioType),
|
|
!globalAccess, autoInvite);
|
|
|
|
if(sessionBrowser.waitOneMessage(sessionBrowser.getMessageName("on_scheduleSessionResult")))
|
|
{
|
|
if(sessionBrowser._LastScheduleSessionResult==0)
|
|
{
|
|
// start session
|
|
sessionBrowser.startSession(sessionBrowser._LastScheduleSessionCharId,
|
|
sessionBrowser._LastScheduleSessionId);
|
|
|
|
if(sessionBrowser.waitOneMessage(sessionBrowser.getMessageName("on_invokeResult")))
|
|
{
|
|
|
|
if (launchScenarioFromRingAccessPoint)
|
|
{
|
|
if (!initialIsland.empty() && !initialEntryPoint.empty() && !initialSeason.empty())
|
|
{
|
|
sessionBrowser.setSessionStartParams(charId, sessionBrowser._LastScheduleSessionId, initialIsland, initialEntryPoint, initialSeason);
|
|
}
|
|
}
|
|
|
|
TSessionPartStatus sessionStatus;
|
|
if(ruleType==TRuleType::rt_liberal)
|
|
sessionStatus = TSessionPartStatus(TSessionPartStatus::sps_play_invited);
|
|
else
|
|
sessionStatus = TSessionPartStatus(TSessionPartStatus::sps_anim_invited);
|
|
|
|
// invite player
|
|
sessionBrowser.inviteCharacter(
|
|
sessionBrowser._LastScheduleSessionCharId,
|
|
sessionBrowser._LastScheduleSessionId,
|
|
sessionBrowser._LastScheduleSessionCharId,
|
|
sessionStatus.toString());
|
|
|
|
if(sessionBrowser.waitOneMessage(sessionBrowser.getMessageName("on_invokeResult")))
|
|
{
|
|
// request session
|
|
FarTP.requestFarTPToSession(sessionBrowser._LastScheduleSessionId, PlayerSelectedSlot, CFarTP::JoinSession,
|
|
!R2::getEditor().isInitialized());
|
|
}
|
|
else
|
|
{
|
|
nlwarning("inviteCharacter callback return false");
|
|
}
|
|
|
|
if (sessionBrowser._LastInvokeResult != 0)
|
|
{
|
|
nlwarning("inviteCharacter callback use error values %d", sessionBrowser._LastInvokeResult);
|
|
}
|
|
|
|
if(sessionBrowser._LastInvokeResult == 14)
|
|
{
|
|
CViewText* pVT = dynamic_cast<CViewText*>(pIM->getElementFromId("ui:interface:warning_free_trial:text"));
|
|
if (pVT != NULL)
|
|
pVT->setText(CI18N::get("uiRingWarningFreeTrial"));
|
|
pIM->runActionHandler("enter_modal", pCaller, "group=ui:interface:warning_free_trial");
|
|
}
|
|
|
|
|
|
// invite team
|
|
if(inviteTeam)
|
|
{
|
|
for (uint i = 0 ; i < 8 ; ++i)
|
|
{
|
|
uint32 val = pIM->getDbProp(NLMISC::toString("SERVER:GROUP:%d:NAME",i))->getValue32();
|
|
if(val!=0)
|
|
{
|
|
STRING_MANAGER::CStringManagerClient *pSMC = STRING_MANAGER::CStringManagerClient::instance();
|
|
ucstring res;
|
|
if (pSMC->getString(val,res))
|
|
{
|
|
string charName = CEntityCL::removeTitleAndShardFromName(res).toString();
|
|
sessionBrowser.inviteCharacterByName(sessionBrowser._LastScheduleSessionCharId, charName);
|
|
|
|
if(!sessionBrowser.waitOneMessage(sessionBrowser.getMessageName("on_invokeResult")))
|
|
{
|
|
nlwarning("inviteCharacterByName callback return false");
|
|
}
|
|
|
|
if(sessionBrowser._LastInvokeResult == 14)
|
|
{
|
|
CViewText* pVT = dynamic_cast<CViewText*>(pIM->getElementFromId("ui:interface:warning_free_trial:text"));
|
|
if (pVT != NULL)
|
|
pVT->setText(CI18N::get("uiRingWarningInviteFreeTrial"));
|
|
pIM->runActionHandler("enter_modal", pCaller, "group=ui:interface:warning_free_trial");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
nlwarning("startSession callback return false");
|
|
launchSuccess = false;
|
|
}
|
|
}
|
|
else if(sessionBrowser._LastScheduleSessionResult==10)
|
|
{
|
|
pIM->messageBoxWithHelp(CI18N::get("uiRingWarningBanishedPlayer"));
|
|
}
|
|
else
|
|
{
|
|
launchSuccess=false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
nlwarning("scheduleSession callback return false");
|
|
launchSuccess = false;
|
|
}
|
|
|
|
if(!launchSuccess)
|
|
{
|
|
pIM->messageBoxWithHelp(CI18N::get("uiRingLaunchScenarioError"));
|
|
}
|
|
else
|
|
{
|
|
scenarioWnd->setActive(false);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// update session
|
|
sessionBrowser.updateSessionInfo(charId, sessionBrowser._LastScheduleSessionId, title, 0, description, sessionLevel,
|
|
/*TAccessType::at_public, */TEstimatedDuration::et_medium, 0, raceFilter, religionFilter,
|
|
guildFilter, shardFilter, levelFilter, !globalAccess, autoInvite, lang, RSMGR::TSessionOrientation(scenarioType));
|
|
|
|
if(!sessionBrowser.waitOneMessage(sessionBrowser.getMessageName("on_invokeResult")))
|
|
{
|
|
nlwarning("updateSessionInfo callback return false");
|
|
pIM->messageBoxWithHelp(CI18N::get("uiRingUpdateScenarioFiltersError"));
|
|
}
|
|
else
|
|
{
|
|
scenarioWnd->setActive(false);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
REGISTER_ACTION_HANDLER (CAHLoadScenario, "load_scenario");
|
|
|
|
|
|
// ***************************************************************************
|
|
class CAHOpenRingSessions : public IActionHandler
|
|
{
|
|
virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
|
|
{
|
|
if(!R2::getEditor().isInitialized())
|
|
{
|
|
CInterfaceManager *pIM = CInterfaceManager::getInstance();
|
|
CInterfaceGroup* ringSessionsWnd = dynamic_cast<CInterfaceGroup*>(pIM->getElementFromId("ui:interface:ring_sessions"));
|
|
if(!ringSessionsWnd) return;
|
|
ringSessionsWnd->setActive(true);
|
|
}
|
|
}
|
|
};
|
|
REGISTER_ACTION_HANDLER (CAHOpenRingSessions, "open_ring_sessions");
|