aleajactaest/khanat-opennel-code
1
0
Fork 0
mirror of https://port.numenaute.org/aleajactaest/khanat-opennel-code.git synced 2024-12-22 00:48:44 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
khanat-opennel-code/code/ryzom/client/src/connection.cpp

3406 lines
103 KiB
C++
Raw Blame History

// 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");
Reference in a new issue View git blame Copy permalink