?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix UI restore when window is resized while in loading screen
[ryzomcore.git] / ryzom / client / src / connection.cpp
blobce887e48ebc1e59337df98513502bb708a1f15f8
1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
2 // Copyright (C) 2010-2019 Winch Gate Property Limited
3 //
4 // This source file has been modified by the following contributors:
5 // Copyright (C) 2012 Matt RAYKOWSKI (sfb) <matt.raykowski@gmail.com>
6 // Copyright (C) 2013 Laszlo KIS-ADAM (dfighter) <dfighter1985@gmail.com>
7 // Copyright (C) 2014-2020 Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
8 //
9 // This program is free software: you can redistribute it and/or modify
10 // it under the terms of the GNU Affero General Public License as
11 // published by the Free Software Foundation, either version 3 of the
12 // License, or (at your option) any later version.
13 //
14 // This program is distributed in the hope that it will be useful,
15 // but WITHOUT ANY WARRANTY; without even the implied warranty of
16 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 // GNU Affero General Public License for more details.
18 //
19 // You should have received a copy of the GNU Affero General Public License
20 // along with this program. If not, see <http://www.gnu.org/licenses/>.
21
22
23
24
25 //////////////
26 // Includes //
27 //////////////
28 #include "stdpch.h"
29
30 // Misc.
31 #include "nel/misc/i18n.h"
32 #include "nel/misc/path.h"
33 #include "nel/misc/time_nl.h"
34 #include "nel/misc/algo.h"
35 #include "nel/misc/system_utils.h"
36 // 3D Interface.
37 #include "nel/3d/u_driver.h"
38 #include "nel/3d/u_text_context.h"
39 #include "nel/3d/stereo_display.h"
40 // Game Share
41 //#include "game_share/gd_time.h" // \todo GUIGUI : TO DELETE/CHANGE
42 #include "game_share/gender.h"
43 #include "game_share/character_summary.h"
44 #include "game_share/roles.h"
45 #include "game_share/character_title.h"
46 #include "game_share/shard_names.h"
47 #include "game_share/utils.h"
48 #include "game_share/bg_downloader_msg.h"
49
50 // Std.
51 #include <vector>
52 // Client
53 #include "connection.h"
54 #include "nel/gui/action_handler.h"
55 #include "sound_manager.h"
56 #include "input.h"
57 #include "login.h"
58 #include "login_progress_post_thread.h"
59
60 #include "client_cfg.h"
61 #include "actions_client.h"
62 #include "user_entity.h"
63 #include "time_client.h"
64 #include "net_manager.h"
65 #include "string_manager_client.h"
66 #include "far_tp.h"
67 #include "movie_shooter.h"
68
69 // Interface part
70 #include "interface_v3/interface_manager.h"
71 #include "interface_v3/character_3d.h"
72 #include "nel/gui/ctrl_button.h"
73 #include "interface_v3/input_handler_manager.h"
74 #include "nel/gui/group_editbox.h"
75 #include "nel/gui/interface_expr.h"
76 #include "init_main_loop.h"
77 #include "continent_manager.h"
78 #include "interface_v3/group_quick_help.h"
79 #include "nel/gui/dbgroup_combo_box.h"
80
81 #include "r2/dmc/client_edition_module.h"
82 #include "r2/editor.h"
83 #include "game_share/scenario.h"
84 #include "session_browser_impl.h"
85
86 #include "bg_downloader_access.h"
87 #include "main_loop.h"
88
89 #include "misc.h"
90
91
92 ////////////////
93 // Namespaces //
94 ////////////////
95 using namespace NLMISC;
96 using namespace NL3D;
97 using namespace NLNET;
98 using namespace std;
99 using namespace RSMGR;
100 using namespace R2;
101
102
103
104 /////////////
105 // Externs //
106 /////////////
107 extern uint32 Version; // Client Version.
108 extern UDriver *Driver;
109 extern UTextContext *TextContext;
110 extern bool game_exit;
111
112 extern CSoundManager *SoundMngr;
113
114 extern bool serverReceivedReady;
115 extern CContinentManager ContinentMngr;
116
117 extern bool MovieShooterSaving;
118 extern void endMovieShooting();
119 extern void replayMovieShooting();
120 extern void saveMovieShooting();
121 extern void displaySpecialTextProgress(const char *text);
122 extern bool InitMouseWithCursor(bool hardware);
123
124 extern bool SetMousePosFirstTime;
125
126 /////////////
127 // Globals // initialization occurs in the function : connection
128 /////////////
129 bool userChar;
130 bool noUserChar;
131 bool ConnectInterf;
132 bool CreateInterf;
133 bool CharacterInterf;
134 TTime UniversalTime;
135 std::vector<CCharacterSummary> CharacterSummaries;
136 std::string UsedFSAddr;
137 std::string UserPrivileges;
138 uint8 ServerPeopleActive = 255;
139 uint8 ServerCareerActive = 255;
140
141 bool WaitServerAnswer;
142 bool CharNameValidArrived;
143 bool CharNameValid;
144 string CharNameValidDBLink;
145 uint8 PlayerSelectedSlot = 0;
146 string PlayerSelectedFileName;
147 TSessionId PlayerSelectedMainland= (TSessionId)0; // This is the mainland selected at the SELECT perso!!
148 std::string PlayerSelectedHomeShardName;
149 std::string PlayerSelectedHomeShardNameWithParenthesis;
150 extern std::string CurrentCookie;
151
152 std::string NewKeysCharNameWanted; // name of the character for which a new keyset must be created
153 std::string NewKeysCharNameValidated;
154 std::string GameKeySet = "keys.xml";
155 std::string RingEditorKeySet = "keys_r2ed.xml";
156
157 string ScenarioFileName;
158 sint LoginCharsel = -1;
159
160 std::string ImportCharacter;
161
162 static const char *KeySetVarName = "BuiltInKeySets";
163
164 #define GROUP_LIST_CHARACTER "ui:outgame:charsel_import:import_list"
165 #define GROUP_LIST_MAINLAND "ui:outgame:appear_mainland:mainland_list"
166 #define GROUP_LIST_KEYSET "ui:outgame:appear_keyset:keyset_list"
167 vector<CMainlandSummary> Mainlands;
168 TSessionId MainlandSelected = (TSessionId)0; // This is the mainland selected at the CREATE perso!!
169
170 // This is the home session (mainland) of the selected character
171 TSessionId CharacterHomeSessionId = (TSessionId)0;
172
173
174 bool PatchBegun = false;
175
176 // \todo GUIGUI : USE TRANSPORT CLASS.
177 // SVersionAnswer versionAnswer;
178
179
180 // Finite State Machine : all the states before entering the game
181 // ------------------------------------------------------------------------------------------------
182 TInterfaceState globalMenu();
183
184
185 bool hasPrivilegeDEV() { return (UserPrivileges.find(":DEV:") != std::string::npos); }
186 bool hasPrivilegeSGM() { return (UserPrivileges.find(":SGM:") != std::string::npos); }
187 bool hasPrivilegeGM() { return (UserPrivileges.find(":GM:") != std::string::npos); }
188 bool hasPrivilegeVG() { return (UserPrivileges.find(":VG:") != std::string::npos); }
189 bool hasPrivilegeSG() { return (UserPrivileges.find(":SG:") != std::string::npos); }
190 bool hasPrivilegeG() { return (UserPrivileges.find(":G:") != std::string::npos); }
191 bool hasPrivilegeEM() { return (UserPrivileges.find(":EM:") != std::string::npos); }
192 bool hasPrivilegeEG() { return (UserPrivileges.find(":EG:") != std::string::npos); }
193
194
195 // Restore the video mode (fullscreen for example) after the connection (done in a window)
196 void connectionRestoreVideoMode ()
197 {
198 // Setup full screen if we have to
199 UDriver::CMode mode;
200 Driver->getCurrentScreenMode(mode);
201
202 if (mode.Windowed)
203 {
204 uint32 width, height;
205 Driver->getWindowSize(width, height);
206 mode.Width = width;
207 mode.Height = height;
208 }
209
210 // don't allow sizes smaller than 1024x768
211 if (ClientCfg.Width < 1024) ClientCfg.Width = 1024;
212 if (ClientCfg.Height < 768) ClientCfg.Height = 768;
213
214 if (StereoDisplay)
215 StereoDisplayAttached = StereoDisplay->attachToDisplay();
216
217 if (!StereoDisplayAttached && (
218 (ClientCfg.Windowed != mode.Windowed) ||
219 (ClientCfg.Width != mode.Width) ||
220 (ClientCfg.Height != mode.Height)))
221 {
222 mode.Windowed = ClientCfg.Windowed;
223 mode.Depth = uint8(ClientCfg.Depth);
224 mode.Width = ClientCfg.Width;
225 mode.Height = ClientCfg.Height;
226 mode.Frequency = ClientCfg.Frequency;
227 setVideoMode(mode);
228 }
229
230 // And setup hardware mouse if we have to
231 InitMouseWithCursor (ClientCfg.HardwareCursor && !StereoDisplayAttached);
232 SetMouseFreeLook ();
233 SetMouseCursor ();
234 SetMouseSpeed (ClientCfg.CursorSpeed);
235 SetMouseAcceleration (ClientCfg.CursorAcceleration);
236
237 // Restore user UI scaling
238 CViewRenderer::getInstance()->setInterfaceScale(ClientCfg.InterfaceScale);
239 }
240
241
242 #define UI_VARIABLES_SCREEN_WEBSTART 8
243
244
245 // ***************************************************************************
246 // Called to reload the start test page in test browser mode
247 class CAHOnReloadTestPage: public IActionHandler
248 {
249 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
250 {
251 CInterfaceManager *pIM = CInterfaceManager::getInstance();
252 // need to reset password and current screen
253 CGroupHTML *pGH = dynamic_cast<CGroupHTML*>(CWidgetManager::getInstance()->getElementFromId(GROUP_BROWSER));
254
255 pGH->browse(ClientCfg.TestBrowserUrl.c_str());
256
257 }
258 };
259 REGISTER_ACTION_HANDLER (CAHOnReloadTestPage, "on_reload_test_page");
260
261
262 // ------------------------------------------------------------------------------------------------
263 void setOutGameFullScreen()
264 {
265 if (!ClientCfg.Local && ClientCfg.SelectCharacter == -1)
266 {
267 if (StereoDisplayAttached)
268 StereoDisplay->detachFromDisplay();
269 StereoDisplayAttached = false;
270
271 InitMouseWithCursor(ClientCfg.HardwareCursor && !StereoDisplayAttached);
272 }
273
274 // Enable auto scaling in login window
275 CViewRenderer::getInstance()->setInterfaceScale(1.0f, 1024, 768);
276 }
277
278 // ------------------------------------------------------------------------------------------------
279 class CSoundGlobalMenu
280 {
281 public:
282 CSoundGlobalMenu()
283 {
284 _MusicWantedAsync= false;
285 _NbFrameBeforeChange= NbFrameBeforeChangeMax;
286 }
287 void reset();
288 void setMusic(const string &music, bool async);
289 void updateSound();
290 private:
291 string _MusicPlayed;
292 string _MusicWanted;
293 bool _MusicWantedAsync;
294 sint _NbFrameBeforeChange;
295 enum {NbFrameBeforeChangeMax= 10};
296 };
297
298 void CSoundGlobalMenu::reset()
299 {
300 _MusicPlayed.clear();
301 _MusicWanted.clear();
302 }
303
304 void CSoundGlobalMenu::updateSound()
305 {
306 // **** update the music played
307 // The first music played is the music played at loading, before select char
308 if (_MusicPlayed.empty())
309 _MusicPlayed = toLowerAscii(LoadingMusic.empty() ? ClientCfg.StartMusic : LoadingMusic);
310 if (_MusicWanted.empty())
311 _MusicWanted = toLowerAscii(LoadingMusic.empty() ? ClientCfg.StartMusic : LoadingMusic);
312
313 // because music is changed when the player select other race for instance,
314 // wait the 3D to load (stall some secs)
315
316 // if the wanted music is the same as the one currently playing, just continue playing
317 if(_MusicPlayed!=_MusicWanted)
318 {
319 // wait nbFrameBeforeChangeMax before actually changing the music
320 _NbFrameBeforeChange--;
321 if(_NbFrameBeforeChange<=0)
322 {
323 _MusicPlayed= _MusicWanted;
324 // play the music
325 if (SoundMngr != NULL)
326 SoundMngr->playMusic(_MusicPlayed, 500, _MusicWantedAsync, true, true);
327 }
328 }
329
330
331 // **** update mngr
332 if (SoundMngr != NULL)
333 SoundMngr->update();
334 }
335
336 void CSoundGlobalMenu::setMusic(const string &music, bool async)
337 {
338 _MusicWanted= toLowerAscii(music);
339 _MusicWantedAsync= async;
340 // reset the counter
341 _NbFrameBeforeChange= NbFrameBeforeChangeMax;
342 }
343 static CSoundGlobalMenu SoundGlobalMenu;
344
345
346 // New version of the menu after the server connection
347 //
348 // If you add something in this function, check CFarTP,
349 // some kind of reinitialization might be useful over there.
350 // ------------------------------------------------------------------------------------------------
351 bool connection (const string &cookie, const string &fsaddr)
352 {
353
354 NLMISC::TTime connStart = ryzomGetLocalTime();
355 NLMISC::TTime connLast = connStart;
356 NLMISC::TTime connCurrent = connLast;
357
358 game_exit = false;
359
360 // set resolution from cfg after login
361 connectionRestoreVideoMode ();
362
363 // Preload continents
364 {
365 const string nmsg("Loading continents...");
366 ProgressBar.newMessage (ClientCfg.buildLoadingString(nmsg) );
367 ContinentMngr.preloadSheets();
368
369 connLast = connCurrent;
370 connCurrent = ryzomGetLocalTime();
371 nlinfo ("PROFILE: %d seconds (%d total) for Loading continents", (uint32)(connCurrent-connLast)/1000, (uint32)(connCurrent-connStart)/1000);
372 }
373
374 if (!fsaddr.empty () && !cookie.empty ())
375 {
376 // it means that we have a nel_launcher values, so we are online
377 ClientCfg.Local = 0;
378 nlinfo ("Using the nel launcher parameters '%s' '%s'", cookie.c_str (), fsaddr.c_str ());
379 }
380
381 CInterfaceManager *pIM = CInterfaceManager::getInstance();
382
383 // If the Client is in in Local Mode -> init the Time and return.
384 if (ClientCfg.Local)
385 {
386 #ifdef ENABLE_INCOMING_MSG_RECORDER
387 NetMngr.init("", "");
388 // Set the impulse callback.
389 NetMngr.setImpulseCallback (impulseCallBack);
390 // Set the database.
391 NetMngr.setDataBase (IngameDbMngr.getNodePtr());
392 // init the string manager cache.
393 STRING_MANAGER::CStringManagerClient::instance()->initCache("", ClientCfg.LanguageCode); // VOIR BORIS
394 #endif
395 return true;
396 }
397
398 ProgressBar.setFontFactor(1.0f);
399
400 // Init out game
401 setOutGameFullScreen();
402
403 string nmsg("Initializing outgame...");
404 ProgressBar.newMessage (ClientCfg.buildLoadingString(nmsg) );
405 pIM->initOutGame();
406
407 connLast = connCurrent;
408 connCurrent = ryzomGetLocalTime();
409 nlinfo ("PROFILE: %d seconds (%d total) for Initializing outgame", (uint32)(connCurrent-connLast)/1000, (uint32)(connCurrent-connStart)/1000);
410
411 // Init user interface
412 nmsg = "Initializing user interface...";
413 ProgressBar.newMessage (ClientCfg.buildLoadingString(nmsg) );
414
415 // Hide cursor for interface
416 //Driver->showCursor (false);
417
418 // Init global variables
419 userChar = false;
420 noUserChar = false;
421 ConnectInterf = true;
422 CreateInterf = true;
423 CharacterInterf = true;
424 WaitServerAnswer= false;
425
426 FarTP.setOutgame();
427
428 // Start the finite state machine
429 static bool firstConnection = true;
430 TInterfaceState InterfaceState = AUTO_LOGIN;
431 // TInterfaceState InterfaceState = firstConnection ? AUTO_LOGIN : GLOBAL_MENU;
432 /*if (!firstConnection)
433 {
434 noUserChar = userChar = false;
435 WaitServerAnswer = true;
436 }*/
437
438 NLGUI::CDBManager::getInstance()->getDbProp ("UI:CURRENT_SCREEN")->setValue32(ClientCfg.Local ? 6 : -1); // TMP TMP
439 IngameDbMngr.flushObserverCalls();
440 NLGUI::CDBManager::getInstance()->flushObserverCalls();
441
442 // Active inputs
443 Actions.enable(true);
444 EditActions.enable(true);
445
446 if (ClientCfg.SelectCharacter == -1)
447 {
448 // not initialized at login and remain hardware until here ...
449
450 // Re-initialise the mouse (will be now in hardware mode, if required)
451 //InitMouseWithCursor (ClientCfg.HardwareCursor && !StereoDisplayAttached); // the return value of enableLowLevelMouse() has already been tested at startup
452
453 // no ui init if character selection is automatic
454 //SetMouseFreeLook ();
455 //SetMouseCursor ();
456 SetMouseSpeed (ClientCfg.CursorSpeed);
457 SetMouseAcceleration (ClientCfg.CursorAcceleration);
458
459 NLGUI::CDBManager::getInstance()->getDbProp("UI:SELECTED_SLOT")->setValue32(ClientCfg.SelectedSlot);
460 PlayerSelectedSlot = ClientCfg.SelectedSlot;
461 }
462
463 connLast = connCurrent;
464 connCurrent = ryzomGetLocalTime();
465 nlinfo ("PROFILE: %d seconds (%d total) for Initializing user interface", (uint32)(connCurrent-connLast)/1000, (uint32)(connCurrent-connStart)/1000);
466
467 nlinfo ("PROFILE: %d seconds for connection", (uint32)(ryzomGetLocalTime ()-connStart)/1000);
468
469 // Init web box
470
471 // TMP TMP
472 if (ClientCfg.Local)
473 {
474 InterfaceState = GLOBAL_MENU;
475 }
476
477 // No loading music here, this is right before character selection, using the existing music
478
479 // Create the loading texture. We can't do that before because we need to add search path first.
480 beginLoading (LoadBackground);
481 UseEscapeDuringLoading = USE_ESCAPE_DURING_LOADING;
482
483 while ((InterfaceState != GOGOGO_IN_THE_GAME) && (InterfaceState != QUIT_THE_GAME))
484 {
485 switch (InterfaceState)
486 {
487 case AUTO_LOGIN:
488 InterfaceState = autoLogin (cookie, fsaddr, firstConnection);
489 break;
490
491 case GLOBAL_MENU:
492 if (!ClientCfg.Local)
493 {
494 if (ClientCfg.SelectCharacter == -1)
495 {
496 NLGUI::CDBManager::getInstance()->getDbProp ("UI:CURRENT_SCREEN")->setValue32(0); // 0 == select
497 }
498 }
499 InterfaceState = globalMenu();
500 break;
501 case GOGOGO_IN_THE_GAME:
502 break;
503 case QUIT_THE_GAME:
504 break;
505 }
506 }
507
508 firstConnection = false;
509
510 // Restore user UI scaling
511 CViewRenderer::getInstance()->setInterfaceScale(ClientCfg.InterfaceScale);
512
513 // Disable inputs
514 Actions.enable(false);
515 EditActions.enable(false);
516
517 // resetTextContext ("ingame.ttf", true);
518 resetTextContext ("ryzom.ttf", true);
519
520 if (InterfaceState == GOGOGO_IN_THE_GAME)
521 {
522 // set background downloader to 'paused' to ease loading of client
523 #ifdef RYZOM_BG_DOWNLOADER
524 pauseBGDownloader();
525 #endif
526 return true;
527 }
528
529 if (InterfaceState == QUIT_THE_GAME)
530 return false;
531 nlassert ((InterfaceState == GOGOGO_IN_THE_GAME) || (InterfaceState == QUIT_THE_GAME));
532 return true;
533 }
534
535
536 //
537
538 // Allow user to reselect character after the server reconnection
539 // ------------------------------------------------------------------------------------------------
540 bool reconnection()
541 {
542
543 game_exit = false;
544
545 setOutGameFullScreen();
546
547 // Preload continents
548 {
549 const string nmsg ("Loading continents...");
550 ProgressBar.newMessage (ClientCfg.buildLoadingString(nmsg) );
551 ContinentMngr.preloadSheets();
552 }
553 /*
554 if (!fsaddr.empty () && !cookie.empty ())
555 {
556 // it means that we have a nel_launcher values, so we are online
557 ClientCfg.Local = 0;
558 nlinfo ("Using the nel launcher parameters '%s' '%s'", cookie.c_str (), fsaddr.c_str ());
559 }
560
561 // If the Client is in in Local Mode -> init the Time and return.
562 if (ClientCfg.Local)
563 {
564 #ifdef ENABLE_INCOMING_MSG_RECORDER
565 NetMngr.init("", "");
566 // Set the impulse callback.
567 NetMngr.setImpulseCallback (impulseCallBack);
568 // Set the database.
569 NetMngr.setDataBase (IngameDbMngr.getNodePtr());
570 // init the string manager cache.
571 STRING_MANAGER::CStringManagerClient::instance()->initCache("", ClientCfg.LanguageCode); // VOIR BORIS
572 #endif
573 connectionRestoreVideoMode ();
574 return true;
575 }
576 */
577
578 CInterfaceManager *pIM = CInterfaceManager::getInstance();
579
580 ProgressBar.setFontFactor(1.0f);
581
582 // Init out game
583 SoundGlobalMenu.reset();
584 pIM->initOutGame();
585
586 // Hide cursor for interface
587 Driver->showCursor (false);
588
589 // Init global variables
590 userChar = false;
591 noUserChar = false;
592 ConnectInterf = true;
593 CreateInterf = true;
594 CharacterInterf = true;
595 WaitServerAnswer= false;
596
597 FarTP.setOutgame();
598
599 if (SoundMngr)
600 SoundMngr->setupFadeSound(1.0f, 1.0f);
601
602 // these two globals sequence GlobalMenu to display the character select dialog
603 WaitServerAnswer = true;
604 userChar = true;
605
606 // Start the finite state machine
607 TInterfaceState InterfaceState = GLOBAL_MENU;
608
609 NLGUI::CDBManager::getInstance()->getDbProp ("UI:CURRENT_SCREEN")->setValue32(-1);
610 IngameDbMngr.flushObserverCalls();
611 NLGUI::CDBManager::getInstance()->flushObserverCalls();
612
613 // Active inputs
614 Actions.enable(true);
615 EditActions.enable(true);
616
617 if (ClientCfg.SelectCharacter == -1)
618 {
619 // Re-initialise the mouse (will be now in hardware mode, if required)
620 SetMousePosFirstTime = true;
621 InitMouseWithCursor (ClientCfg.HardwareCursor && !StereoDisplayAttached); // the return value of enableLowLevelMouse() has already been tested at startup
622
623 // no ui init if character selection is automatic
624 SetMouseFreeLook ();
625 SetMouseCursor ();
626 SetMouseSpeed (ClientCfg.CursorSpeed);
627 SetMouseAcceleration (ClientCfg.CursorAcceleration);
628 NLGUI::CDBManager::getInstance()->getDbProp("UI:SELECTED_SLOT")->setValue32(ClientCfg.SelectedSlot);
629 PlayerSelectedSlot = ClientCfg.SelectedSlot;
630 }
631
632 // we want the teleport graphics to display (not like in Server Hop mode)
633 // this also kicks the state machine to sendReady() so we stop spinning in farTPmainLoop
634 FarTP.setIngame();
635
636 // Not loading music here, this is before character selection, keep existing music
637
638 // Create the loading texture. We can't do that before because we need to add search path first.
639 beginLoading (LoadBackground);
640 UseEscapeDuringLoading = USE_ESCAPE_DURING_LOADING;
641
642 // character selection menu
643 while( InterfaceState == GLOBAL_MENU ) // != GOGOGO_IN_THE_GAME) && (InterfaceState != QUIT_THE_GAME))
644 {
645 if (ClientCfg.SelectCharacter == -1)
646 {
647 NLGUI::CDBManager::getInstance()->getDbProp ("UI:CURRENT_SCREEN")->setValue32(0); // 0 == select
648 }
649 InterfaceState = globalMenu();
650 }
651
652 // Restore user UI scaling
653 CViewRenderer::getInstance()->setInterfaceScale(ClientCfg.InterfaceScale);
654
655 // Disable inputs
656 Actions.enable(false);
657 EditActions.enable(false);
658
659 // resetTextContext ("ingame.ttf", true);
660 resetTextContext ("ryzom.ttf", true);
661
662 if (InterfaceState == GOGOGO_IN_THE_GAME)
663 {
664 #ifdef RYZOM_BG_DOWNLOADER
665 pauseBGDownloader();
666 #endif
667 return true;
668 }
669 if (InterfaceState == QUIT_THE_GAME)
670 return false;
671 nlassert ((InterfaceState == GOGOGO_IN_THE_GAME) || (InterfaceState == QUIT_THE_GAME));
672 return true;
673 }
674
675 // Automatic connection to the server, the user can't do anything
676 // ------------------------------------------------------------------------------------------------
677 TInterfaceState autoLogin (const string &cookie, const string &fsaddr, bool firstConnection)
678 {
679 noUserChar = userChar = false;
680 string defaultPort = string(":47851");
681 if(!fsaddr.empty())
682 {
683 // If we have a front end address from command line, use this one
684 UsedFSAddr = fsaddr;
685 if (UsedFSAddr.find(":") == string::npos)
686 {
687 UsedFSAddr += defaultPort;
688 }
689 }
690 else
691 {
692 // Otherwise, use the front end address from configfile
693 UsedFSAddr = ClientCfg.FSHost;
694 FSAddr = UsedFSAddr; // to be able to do /reconnect
695 LoginSM.pushEvent( CLoginStateMachine::ev_skip_all_login );
696 if (UsedFSAddr.find(":") == string::npos)
697 {
698 UsedFSAddr += defaultPort;
699 FSAddr += defaultPort; // to be able to do /reconnect
700 }
701 }
702
703 if (firstConnection)
704 NetMngr.init (cookie, UsedFSAddr);
705
706 // Connection
707 if (!ClientCfg.Local/*ace!ClientCfg.Light*/)
708 {
709 string result;
710
711 if (firstConnection)
712 {
713 NetMngr.connect (result);
714
715 if (!result.empty())
716 {
717 nlerror ("connection : %s.", result.c_str());
718 return QUIT_THE_GAME;
719 }
720
721 // Ok the client is connected
722
723 // Set the impulse callback.
724 NetMngr.setImpulseCallback (impulseCallBack);
725 // Set the database.
726 NetMngr.setDataBase (IngameDbMngr.getNodePtr());
727
728 // init the string manager cache.
729 STRING_MANAGER::CStringManagerClient::instance()->initCache(UsedFSAddr, ClientCfg.LanguageCode);
730 }
731 }
732 else
733 {
734 CCharacterSummary cs;
735 cs.Name = "babar";
736 //cs.Surname = "l'elephant";
737 cs.People = EGSPD::CPeople::Zorai;
738 cs.VisualPropA.PropertySubData.Sex = 0; // Male
739 //Deprecated
740 // cs.Role = ROLES::range_warrior;
741 // cs.Job = JOBS::CasterBuffer;
742 // cs.JobLevel = 16;
743 CharacterSummaries.push_back(cs);
744
745 cs.Name = "yeah";
746 //cs.Surname = "zeelot";
747 cs.People = EGSPD::CPeople::Matis;
748 cs.VisualPropA.PropertySubData.Sex = 1; // Female
749 //Deprecated
750 // cs.Role = ROLES::buffer_magician;
751 // cs.Job = JOBS::CasterHealer;
752 // cs.JobLevel = 8;
753 CharacterSummaries.push_back(cs);
754
755 userChar = true;
756 }
757
758 WaitServerAnswer = true;
759
760 return GLOBAL_MENU;
761 }
762
763 // ------------------------------------------------------------------------------------------------
764 void globalMenuMovieShooter()
765 {
766
767 if(MovieShooterSaving)
768 {
769 // Add the buffer frame to the movie.
770 if(!MovieShooter.addFrame(TimeInSec, Driver))
771 {
772 // Fail to add the frame => abort.
773 endMovieShooting();
774 }
775 else
776 {
777 // Ok, just add a display.
778 displaySpecialTextProgress("MovieShooting");
779 }
780 }
781
782 }
783
784 // ------------------------------------------------------------------------------------------------
785 // Build a valid PlayerName for file Save selection.
786 std::string buildPlayerNameForSaveFile(const std::string &playerNameIn)
787 {
788 // remove any shard name appended
789 string playerName = playerNameIn;
790 string::size_type pos = playerNameIn.find('(');
791 if(pos!=string::npos && pos>0)
792 {
793 playerName.resize(pos);
794 }
795
796 // replace any special ucchar with '_'
797 string ret;
798 ret.resize(playerName.size());
799 for(uint i=0;i<playerName.size();i++)
800 {
801 ucchar c= playerName[i];
802 if( (c>='A' && c<='Z') ||
803 (c>='a' && c<='z') ||
804 (c>='0' && c<='9') ||
805 (c=='_') )
806 {
807 ret[i]= tolower(c); // TODO: toLowerAscii
808 }
809 else
810 ret[i]= '_';
811 }
812 return ret;
813 }
814
815
816 #ifdef RYZOM_BG_DOWNLOADER
817 static bool LuaBGDSuccessFlag = true; // tmp, for debug
818
819 void updateBGDownloaderUI()
820 {
821 CInterfaceManager *im = CInterfaceManager::getInstance();
822 CBGDownloaderAccess &bgDownloader = CBGDownloaderAccess::getInstance();
823 bool bgWindowVisible = true;
824 if (im->isInGame())
825 {
826 static NLMISC::CRefPtr<CInterfaceElement> bgDownloaderWindow;
827 if (!bgDownloaderWindow)
828 {
829 bgDownloaderWindow = CWidgetManager::getInstance()->getElementFromId("ui:interface:bg_downloader");
830 }
831 bgWindowVisible = bgDownloaderWindow && bgDownloaderWindow->getActive();
832 }
833 bool prevSuccess = LuaBGDSuccessFlag;
834 if (isBGDownloadEnabled() && PatchBegun)
835 {
836 if (AvailablePatchs == 0)
837 {
838 if (LuaBGDSuccessFlag)
839 {
840 LuaBGDSuccessFlag = CLuaManager::getInstance().executeLuaScript("bgdownloader:setPatchSuccess()");
841 }
842 }
843 else
844 {
845 switch(bgDownloader.getLastTaskResult())
846 {
847 case BGDownloader::TaskResult_Unknown:
848 {
849 float progress = 0.f;
850 /*if (bgDownloader.getTotalSize() != 0)
851 {
852 progress = (float) bgDownloader.getPatchingSize() / bgDownloader.getTotalSize();
853 }*/
854 if (bgDownloader.getTotalFilesToGet() != 0)
855 {
856 progress = (bgDownloader.getCurrentFilesToGet() + bgDownloader.getCurrentFileProgress()) / bgDownloader.getTotalFilesToGet();
857 }
858 if (LuaBGDSuccessFlag && bgWindowVisible)
859 {
860 LuaBGDSuccessFlag = CLuaManager::getInstance().executeLuaScript(toString("bgdownloader:setPatchProgress(%f)", progress));
861 }
862 // display current priority of the downloader
863 if (LuaBGDSuccessFlag && bgWindowVisible)
864 {
865 LuaBGDSuccessFlag = CLuaManager::getInstance().executeLuaScript("bgdownloader:displayPriority()");
866 }
867 }
868 break;
869 case BGDownloader::TaskResult_Success:
870 if (LuaBGDSuccessFlag && bgWindowVisible)
871 {
872 LuaBGDSuccessFlag = CLuaManager::getInstance().executeLuaScript("bgdownloader:setPatchSuccess()");
873 }
874 // task finished
875 AvailablePatchs = 0;
876 if (bgDownloader.getPatchCompletionFlag(true /* clear flag */))
877 {
878 // when in-game, display a message to signal the end of the patch
879 if (im->isInGame())
880 {
881 im->displaySystemInfo(CI18N::get("uiBGD_InGamePatchCompletion"), "BC");
882 }
883 }
884 break;
885 default:
886 // error case
887 if (LuaBGDSuccessFlag && bgWindowVisible)
888 {
889 LuaBGDSuccessFlag = CLuaManager::getInstance().executeLuaScript("bgdownloader:setPatchError()");
890 }
891 break;
892 }
893 }
894 }
895 else
896 {
897 if (LuaBGDSuccessFlag && bgWindowVisible)
898 {
899 if (isBGDownloadEnabled())
900 {
901 // no necessary patch for now
902 LuaBGDSuccessFlag = CLuaManager::getInstance().executeLuaScript("bgdownloader:setNoNecessaryPatch()");
903 }
904 else
905 {
906 // no download ui
907 LuaBGDSuccessFlag = CLuaManager::getInstance().executeLuaScript("bgdownloader:setNoDownloader()");
908 }
909 }
910 }
911 if (prevSuccess != LuaBGDSuccessFlag)
912 {
913 nlwarning("Some scipt error occurred");
914 }
915 }
916 #endif
917
918 // compute patcher priority, depending on the presence of one or more mainland characters : in this case, give the patch a boost
919 void updatePatcherPriorityBasedOnCharacters()
920 {
921 #ifdef RYZOM_BG_DOWNLOADER
922 if (isBGDownloadEnabled())
923 {
924 if (CBGDownloaderAccess::getInstance().getDownloadThreadPriority() != BGDownloader::ThreadPriority_Paused)
925 {
926 // choose priority based on available characters :
927 bool hasMainlandChar = false;
928 for(std::vector<CCharacterSummary>::iterator it = CharacterSummaries.begin(); it != CharacterSummaries.end(); ++it)
929 {
930 if (it->Name.empty()) continue;
931 if (!it->InNewbieland)
932 {
933 hasMainlandChar = true;
934 break;
935 }
936 }
937 CBGDownloaderAccess::getInstance().requestDownloadThreadPriority(hasMainlandChar ? BGDownloader::ThreadPriority_Normal : BGDownloader::ThreadPriority_Low, false);
938 }
939 }
940 #endif
941 }
942
943 // Launch the interface to choose a character
944 // ------------------------------------------------------------------------------------------------
945 TInterfaceState globalMenu()
946 {
947 CLoginProgressPostThread::getInstance().step(CLoginStep(LoginStep_CharacterSelection, "login_step_character_selection"));
948
949 #ifdef RYZOM_BG_DOWNLOADER
950 CBGDownloaderAccess &bgDownloader = CBGDownloaderAccess::getInstance();
951
952 if (isBGDownloadEnabled())
953 {
954 // If there's a need for mainland download, then proceed
955 if (AvailablePatchs & (1 << BGDownloader::DownloadID_MainLand))
956 {
957 // if a task is already started, then this was a situation where player went back from game to the character selection,
958 // so just unpause
959 BGDownloader::TTaskResult dummyResult;
960 ucstring dummyMessage; // OLD
961 if (!bgDownloader.isTaskEnded(dummyResult, dummyMessage))
962 {
963 unpauseBGDownloader();
964 }
965 }
966 }
967 #endif
968
969 CInterfaceManager *pIM = CInterfaceManager::getInstance();
970
971 sint32 nScreenConnecting, nScreenIntro, nScreenServerCrashed;
972 fromString(CWidgetManager::getInstance()->getParser()->getDefine("screen_connecting"), nScreenConnecting);
973 fromString(CWidgetManager::getInstance()->getParser()->getDefine("screen_intro"), nScreenIntro);
974 fromString(CWidgetManager::getInstance()->getParser()->getDefine("screen_crashing"), nScreenServerCrashed);
975
976 // SKIP INTRO : Write to the database if we have to skip the intro and write we want to skip further intro to client cfg
977 if (ClientCfg.SkipIntro)
978 {
979 CCDBNodeLeaf *pNL = NLGUI::CDBManager::getInstance()->getDbProp("UI:TEMP:SKIP_INTRO", false);
980 if (pNL != NULL)
981 pNL->setValue64(1);
982 }
983
984 TGameCycle serverTick = NetMngr.getCurrentServerTick();
985 bool PlayerWantToGoInGame = false;
986 bool firewallTimeout = false;
987
988 ProgressBar.finish(); // no progress while selecting character
989
990 while (PlayerWantToGoInGame == false)
991 {
992
993 #if defined(NL_OS_WINDOWS) && defined(NL_DEBUG) && 0
994 // tmp for debug
995 if (::GetAsyncKeyState(VK_SPACE))
996 {
997 pIM->uninitOutGame();
998 pIM->initOutGame();
999 CWidgetManager::getInstance()->activateMasterGroup ("ui:outgame", true);
1000 NLGUI::CDBManager::getInstance()->getDbProp ("UI:CURRENT_SCREEN")->setValue32(2); // TMP TMP
1001 IngameDbMngr.flushObserverCalls();
1002 NLGUI::CDBManager::getInstance()->flushObserverCalls();
1003 CWidgetManager::getInstance()->getElementFromId("ui:outgame:charsel")->setActive(false);
1004 CWidgetManager::getInstance()->getElementFromId("ui:outgame:charsel")->setActive(true);
1005 // Active inputs
1006 Actions.enable(true);
1007 EditActions.enable(true);
1008 LuaBGDSuccessFlag = true;
1009 CWidgetManager::getInstance()->getParser()->reloadAllLuaFileScripts();
1010 }
1011 #endif
1012
1013 #ifdef RYZOM_BG_DOWNLOADER
1014 updateBGDownloaderUI();
1015 #endif
1016
1017 // Update network.
1018 try
1019 {
1020 if ( ! firewallTimeout )
1021 NetMngr.update();
1022 }
1023 catch (const EBlockedByFirewall&)
1024 {
1025 if ( NetMngr.getConnectionState() == CNetManager::Disconnect )
1026 {
1027 firewallTimeout = true;
1028 }
1029 else
1030 {
1031 // Display the firewall alert string
1032 CViewText *pVT = dynamic_cast<CViewText*>(CWidgetManager::getInstance()->getElementFromId("ui:outgame:connecting:title"));
1033 if (pVT != NULL)
1034 pVT->setTextLocalized("uiFirewallAlert", true);
1035
1036 // The mouse and fullscreen mode should be unlocked for the user to set the firewall permission
1037 nlSleep( 30 ); // 'nice' the client, and prevent to make too many send attempts
1038 }
1039
1040 }
1041 IngameDbMngr.flushObserverCalls();
1042 NLGUI::CDBManager::getInstance()->flushObserverCalls();
1043
1044 // check if we can send another dated block
1045 if (NetMngr.getCurrentServerTick() != serverTick)
1046 {
1047 //
1048 serverTick = NetMngr.getCurrentServerTick();
1049 NetMngr.send(serverTick);
1050 }
1051 else
1052 {
1053 // Send dummy info
1054 NetMngr.send();
1055 }
1056 // Update the DT T0 and T1 global variables
1057 updateClientTime();
1058 CInputHandlerManager::getInstance()->pumpEvents();
1059 Driver->clearBuffers(CRGBA::Black);
1060 Driver->setMatrixMode2D11();
1061
1062 // Update sound
1063 SoundGlobalMenu.updateSound();
1064
1065 // Interface handling & displaying (processes clicks...)
1066 pIM->updateFrameEvents();
1067 pIM->updateFrameViews(NULL);
1068 IngameDbMngr.flushObserverCalls();
1069 NLGUI::CDBManager::getInstance()->flushObserverCalls();
1070
1071 // Movie shooter
1072 globalMenuMovieShooter();
1073
1074 // Force the client to sleep a bit.
1075 if(ClientCfg.Sleep >= 0)
1076 {
1077 nlSleep(ClientCfg.Sleep);
1078 }
1079
1080 #if defined(NL_OS_WINDOWS) && defined(NL_DEBUG) && 0
1081 if (::GetAsyncKeyState(VK_CONTROL))
1082 {
1083 pIM->displayUIViewBBoxs("");
1084 pIM->displayUICtrlBBoxs("");
1085 pIM->displayUIGroupBBoxs("");
1086 displayDebugUIUnderMouse();
1087 }
1088 #endif
1089
1090 // Display
1091 Driver->swapBuffers();
1092
1093 // SERVER INTERACTIONS WITH INTERFACE
1094 if (WaitServerAnswer)
1095 {
1096 if (noUserChar || userChar)
1097 {
1098 #ifdef RYZOM_BG_DOWNLOADER
1099 if (isBGDownloadEnabled())
1100 {
1101 // If there's a need for mainland download, then proceed
1102 if (AvailablePatchs & (1 << BGDownloader::DownloadID_MainLand))
1103 {
1104 // if a task is already started, then this was a situation where player went back from game to the character selection,
1105 // so just unpause
1106 BGDownloader::TTaskResult dummyResult;
1107 ucstring dummyMessage; // OLD
1108 if (bgDownloader.isTaskEnded(dummyResult, dummyMessage))
1109 {
1110 // launch mainland patch as a background task
1111 BGDownloader::CTaskDesc task(BGDownloader::DLState_GetAndApplyPatch,
1112 (1 << BGDownloader::DownloadID_MainLand));
1113 bgDownloader.startTask(task, getBGDownloaderCommandLine(), false /* showDownloader */);
1114
1115 // choose priority based on available characters :
1116 updatePatcherPriorityBasedOnCharacters();
1117
1118 PatchBegun = true;
1119 }
1120 }
1121 }
1122 #endif
1123
1124 //nlinfo("impulseCallBack : received userChars list");
1125 noUserChar = userChar = false;
1126 if( FarTP.isReselectingChar() || !FarTP.isServerHopInProgress() ) // if doing a Server Hop, expect serverReceivedReady without action from the user
1127 {
1128 sint charSelect = -1;
1129 if (ClientCfg.SelectCharacter != -1)
1130 charSelect = ClientCfg.SelectCharacter;
1131
1132 if (LoginCharsel != -1)
1133 charSelect = LoginCharsel;
1134
1135 WaitServerAnswer = false;
1136 if (charSelect == -1)
1137 {
1138 CCDBNodeLeaf *pNL = NLGUI::CDBManager::getInstance()->getDbProp("UI:SERVER_RECEIVED_CHARS", false);
1139 if (pNL != NULL)
1140 {
1141 pNL->setValue64 (1); // Send impulse to interface observers
1142 IngameDbMngr.flushObserverCalls();
1143 NLGUI::CDBManager::getInstance()->flushObserverCalls();
1144 pNL->setValue64 (0);
1145 IngameDbMngr.flushObserverCalls();
1146 NLGUI::CDBManager::getInstance()->flushObserverCalls();
1147 }
1148 }
1149 else
1150 {
1151 // check that the pre selected character is available
1152 if (CharacterSummaries[charSelect].People == EGSPD::CPeople::Unknown || charSelect > 4)
1153 {
1154 // BAD ! preselected char does not exist, use the first available or fail
1155 uint i;
1156 for (i=0; i<CharacterSummaries.size(); ++i)
1157 {
1158 if (CharacterSummaries[i].People != EGSPD::CPeople::Unknown)
1159 break;
1160 }
1161 if (i == CharacterSummaries.size())
1162 {
1163 Driver->systemMessageBox("You have no character for the current user.\nClient will exit.", "Char loading error", UDriver::okType, UDriver::exclamationIcon);
1164 exit(-1);
1165 }
1166 else
1167 {
1168 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);
1169 if (ret == UDriver::noId)
1170 exit(-1);
1171 else
1172 charSelect = i;
1173 }
1174 }
1175 // Auto-selection for fast launching (dev only)
1176 CAHManager::getInstance()->runActionHandler("launch_game", NULL, toString("slot=%d|edit_mode=0", charSelect));
1177
1178 if (LoginCharsel == -1)
1179 ClientCfg.SelectCharacter = charSelect;
1180 }
1181
1182 }
1183
1184 // Clear sending buffer that may contain prevous QUIT_GAME when getting back to the char selection screen
1185 NetMngr.flushSendBuffer();
1186 }
1187
1188 if (CharNameValidArrived)
1189 {
1190 //nlinfo("impulseCallBack : received CharNameValidArrived");
1191 CharNameValidArrived = false;
1192 WaitServerAnswer = false;
1193 if (ClientCfg.SelectCharacter == -1)
1194 {
1195 CCDBNodeLeaf *pNL;
1196 pNL = NLGUI::CDBManager::getInstance()->getDbProp(CharNameValidDBLink,false);
1197 if (pNL != NULL)
1198 {
1199 if (CharNameValid)
1200 pNL->setValue64(1);
1201 else
1202 pNL->setValue64(0);
1203 }
1204
1205 pNL = NLGUI::CDBManager::getInstance()->getDbProp("UI:SERVER_RECEIVED_VALID", false);
1206 if (pNL != NULL)
1207 {
1208 pNL->setValue64 (1); // Send impulse to interface observers
1209 IngameDbMngr.flushObserverCalls();
1210 NLGUI::CDBManager::getInstance()->flushObserverCalls();
1211 pNL->setValue64 (0);
1212 IngameDbMngr.flushObserverCalls();
1213 NLGUI::CDBManager::getInstance()->flushObserverCalls();
1214 }
1215 }
1216 }
1217
1218 if (serverReceivedReady)
1219 {
1220 //nlinfo("impulseCallBack : received serverReceivedReady");
1221 serverReceivedReady = false;
1222 WaitServerAnswer = false;
1223 PlayerWantToGoInGame = true;
1224 }
1225 }
1226 else
1227 {
1228 noUserChar = false;
1229 userChar = false;
1230 CharNameValidArrived = false;
1231 serverReceivedReady = false;
1232 }
1233
1234 // Check if server disconnect the client
1235 if (!ClientCfg.Local)
1236 {
1237 if (NetMngr.getConnectionState() == CNetManager::Disconnect)
1238 {
1239 // Display the connection failure screen
1240 CCDBNodeLeaf *pNL = NLGUI::CDBManager::getInstance()->getDbProp("UI:CURRENT_SCREEN", false);
1241 if (pNL != NULL)
1242 pNL->setValue64 (nScreenServerCrashed);
1243
1244 if ( firewallTimeout )
1245 {
1246 // Display the firewall error string instead of the normal failure string
1247 CViewText *pVT = dynamic_cast<CViewText*>(CWidgetManager::getInstance()->getElementFromId("ui:outgame:crashing:title"));
1248 if (pVT != NULL)
1249 {
1250 pVT->setMultiLine( true );
1251 pVT->setTextLocalized(CI18N::get("uiFirewallFail")+".\n"+
1252 CI18N::get("uiFirewallAlert")+".", false);
1253 }
1254 }
1255 }
1256 }
1257
1258
1259
1260 // We want to quit the game without playing
1261 if (game_exit)
1262 return QUIT_THE_GAME;
1263 }
1264
1265 if (ClientCfg.SelectCharacter != -1)
1266 PlayerSelectedSlot = ClientCfg.SelectCharacter;
1267
1268 // Notify the state machine that we're exiting from global menu
1269 LoginSM.pushEvent(CLoginStateMachine::ev_global_menu_exited);
1270
1271 // Init the current Player Name (for interface.cfg and sentence.name save). Make a good File Name.
1272 string playerName = CharacterSummaries[PlayerSelectedSlot].Name.toUtf8();
1273 PlayerSelectedFileName = buildPlayerNameForSaveFile(playerName);
1274
1275 // Init the current Player Home shard Id and name
1276 CharacterHomeSessionId = CharacterSummaries[PlayerSelectedSlot].Mainland;
1277 PlayerSelectedMainland= CharacterSummaries[PlayerSelectedSlot].Mainland;
1278 PlayerSelectedHomeShardName.clear();
1279 PlayerSelectedHomeShardNameWithParenthesis.clear();
1280 for(uint i=0;i<CShardNames::getInstance().getSessionNames().size();i++)
1281 {
1282 const CShardNames::TSessionName &sessionName= CShardNames::getInstance().getSessionNames()[i];
1283 if(PlayerSelectedMainland == sessionName.SessionId)
1284 {
1285 PlayerSelectedHomeShardName= sessionName.DisplayName;
1286 PlayerSelectedHomeShardNameWithParenthesis= '(' + PlayerSelectedHomeShardName + ')';
1287 }
1288 }
1289
1290
1291 // Restore video mode
1292 if (ClientCfg.SelectCharacter == -1)
1293 connectionRestoreVideoMode ();
1294
1295 // Skip intro next time
1296 ClientCfg.writeBool("SkipIntro", true);
1297
1298 // return SELECT_CHARACTER;
1299 return GOGOGO_IN_THE_GAME;
1300 }
1301
1302
1303 // Init the character selection slot texts from the character summaries
1304 // ------------------------------------------------------------------------------------------------
1305 class CAHNetInitCharSel : public IActionHandler
1306 {
1307 public:
1308 virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
1309 {
1310 string sPath = getParam(Params, "slottexts");
1311 CInterfaceManager *pIM = CInterfaceManager::getInstance();
1312 uint i;
1313 for (i = 0; i < CharacterSummaries.size(); ++i)
1314 {
1315 CCharacterSummary &rCS = CharacterSummaries[i];
1316 CInterfaceElement *pIE = CWidgetManager::getInstance()->getElementFromId(sPath+":text"+NLMISC::toString(i));
1317 CViewText *pVT = dynamic_cast<CViewText*>(pIE);
1318 if (pVT == NULL) return;
1319
1320 if (rCS.Name.empty())
1321 pVT->setTextLocalized("uiEmptySlot", true);
1322 else
1323 pVT->setTextLocalized(rCS.Name.toUtf8(), false);
1324 }
1325 // 5 slots
1326 for (; i < 5; ++i)
1327 {
1328 CViewText *pVT = dynamic_cast<CViewText*>(CWidgetManager::getInstance()->getElementFromId(sPath+":text"+NLMISC::toString(i)));
1329 if (pVT == NULL) return;
1330 pVT->setTextLocalized("uiEmptySlot", true);
1331 }
1332 }
1333 };
1334 REGISTER_ACTION_HANDLER (CAHNetInitCharSel, "net_init_char_sel");
1335
1336 // ------------------------------------------------------------------------------------------------
1337 void setTarget(CCtrlBase *ctrl, const string &targetName, std::string &value)
1338 {
1339 std::vector<CInterfaceLink::CTargetInfo> targets;
1340 // find first enclosing group
1341 CCtrlBase *currCtrl = ctrl;
1342 CInterfaceGroup *ig = NULL;
1343 while (currCtrl)
1344 {
1345 ig = dynamic_cast<CInterfaceGroup *>(currCtrl);
1346 if (ig != NULL) break;
1347 currCtrl = currCtrl->getParent();
1348 }
1349 if (ig)
1350 {
1351 CInterfaceExprValue exprValue;
1352 exprValue.setString(value);
1353
1354 CInterfaceLink::splitLinkTargets(targetName, ig, targets);
1355 for(uint k = 0; k < targets.size(); ++k)
1356 {
1357 if (targets[k].Elem) targets[k].affect(exprValue);
1358 }
1359 }
1360 }
1361
1362 // ------------------------------------------------------------------------------------------------
1363 void setTarget(CCtrlBase *ctrl, const string &targetName, uint32 value)
1364 {
1365 std::vector<CInterfaceLink::CTargetInfo> targets;
1366 // find first enclosing group
1367 CCtrlBase *currCtrl = ctrl;
1368 CInterfaceGroup *ig = NULL;
1369 while (currCtrl)
1370 {
1371 ig = dynamic_cast<CInterfaceGroup *>(currCtrl);
1372 if (ig != NULL) break;
1373 currCtrl = currCtrl->getParent();
1374 }
1375 if (ig)
1376 {
1377 CInterfaceExprValue exprValue;
1378 exprValue.setInteger(value);
1379
1380 CInterfaceLink::splitLinkTargets(targetName, ig, targets);
1381 for(uint k = 0; k < targets.size(); ++k)
1382 {
1383 if (targets[k].Elem) targets[k].affect(exprValue);
1384 }
1385 }
1386 }
1387
1388 // ------------------------------------------------------------------------------------------------
1389 class CAHGetSlot: public IActionHandler
1390 {
1391 public:
1392 virtual void execute (CCtrlBase *pCaller, const string &Params)
1393 {
1394 string sProp = getParam(Params, "prop");
1395 string sTarget = getParam(Params, "target");
1396 string sSlot = getParam(Params, "slot");
1397
1398 CInterfaceExprValue result;
1399 if (!CInterfaceExpr::eval(sSlot, result))
1400 return;
1401 uint8 selectedSlot = (uint8)result.getInteger();
1402 if (selectedSlot >= CharacterSummaries.size())
1403 return;
1404
1405 PlayerSelectedSlot = selectedSlot;
1406
1407 if (CharacterSummaries[PlayerSelectedSlot].Name.empty())
1408 return;
1409
1410 string sValue;
1411 uint32 nValue = 0;
1412
1413 if (sProp == "name")
1414 {
1415 sValue = CharacterSummaries[PlayerSelectedSlot].Name.toUtf8();
1416 setTarget (pCaller, sTarget, sValue);
1417 }
1418 /* else if (sProp == "surname")
1419 Deprecated {
1420 sValue = CharacterSummaries[PlayerSelectedSlot].Surname;
1421 setTarget (pCaller, sTarget, sValue);
1422 }
1423 */ else if (sProp == "title")
1424 {
1425 bool womanTitle;
1426 if( CharacterSummaries[PlayerSelectedSlot].VisualPropA.PropertySubData.Sex == 1 )
1427 {
1428 UserEntity->setGender( GSGENDER::female );
1429 womanTitle = true;
1430 }
1431 else
1432 {
1433 UserEntity->setGender( GSGENDER::male );
1434 womanTitle = false;
1435 }
1436 string titleStr = CHARACTER_TITLE::toString(CharacterSummaries[PlayerSelectedSlot].Title);
1437 sValue = STRING_MANAGER::CStringManagerClient::getTitleLocalizedName(titleStr, womanTitle);
1438 {
1439 // Sometimes translation contains another title
1440 string::size_type pos = sValue.find('$');
1441 if (pos != string::npos)
1442 {
1443 sValue = STRING_MANAGER::CStringManagerClient::getTitleLocalizedName(CEntityCL::getTitleFromName(sValue), womanTitle);
1444 }
1445 }
1446 setTarget (pCaller, sTarget, sValue);
1447 }
1448 /* else if (sProp == "orient")
1449 Deprecated {
1450 sValue = ROLES::roleToUCString(CharacterSummaries[PlayerSelectedSlot].Role);
1451 setTarget (pCaller, sTarget, sValue);
1452 }
1453 else if (sProp == "job")
1454 {
1455 //Deprecated
1456 // sValue = JOBS::jobToUCString(CharacterSummaries[PlayerSelectedSlot].Job);
1457 sValue = JOBS::jobToUCString(JOBS::BladeBearer);
1458 setTarget (pCaller, sTarget, sValue);
1459 }
1460 */ else if (sProp == "level")
1461 {
1462 //Deprecated
1463 // sValue = toString(CharacterSummaries[PlayerSelectedSlot].JobLevel);
1464 sValue = toString(1);
1465 setTarget (pCaller, sTarget, sValue);
1466 }
1467 else if (sProp == "pos")
1468 {
1469 nValue = CharacterSummaries[PlayerSelectedSlot].Location;
1470 setTarget (pCaller, sTarget, nValue);
1471 }
1472 }
1473 };
1474 REGISTER_ACTION_HANDLER (CAHGetSlot, "get_slot");
1475
1476
1477 // Setup the database from a database entry which represents a slot
1478 // ------------------------------------------------------------------------------------------------
1479 class CAHSetDBFromSlot : public IActionHandler
1480 {
1481 public:
1482 virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
1483 {
1484 string sDBLink = getParam(Params, "dblink");
1485 string sSlot = getParam(Params, "slot");
1486
1487 CInterfaceExprValue result;
1488 if (!CInterfaceExpr::eval(sSlot, result))
1489 return;
1490
1491 PlayerSelectedSlot = (uint8)result.getInteger();
1492
1493 if (PlayerSelectedSlot >= CharacterSummaries.size())
1494 return;
1495
1496 // Setup the database from the character summary
1497 CCharacterSummary &rCS = CharacterSummaries[PlayerSelectedSlot];
1498 if (rCS.Name.empty())
1499 return;
1500
1501 SCharacter3DSetup::setupDBFromCharacterSummary(sDBLink, rCS);
1502 }
1503 };
1504 REGISTER_ACTION_HANDLER (CAHSetDBFromSlot, "set_db_from_slot");
1505
1506
1507 // Reset all the pushed radio button of a group
1508 // ------------------------------------------------------------------------------------------------
1509 class CAHResetPushed: public IActionHandler
1510 {
1511 public:
1512 virtual void execute (CCtrlBase *pCaller, const string &Params)
1513 {
1514 string sDBLink = getParam(Params, "dblink");
1515 CInterfaceManager *pIM = CInterfaceManager::getInstance();
1516 CInterfaceElement *pIE = CWidgetManager::getInstance()->getElementFromId(pCaller->getId(), sDBLink);
1517 CInterfaceGroup *pIG = dynamic_cast<CInterfaceGroup*>(pIE);
1518 if (pIG == NULL) return;
1519
1520 const vector<CCtrlBase*> vCB = pIG->getControls();
1521 for (uint i = 0; i < vCB.size(); ++i)
1522 {
1523 CCtrlBaseButton *pBut = dynamic_cast<CCtrlBaseButton*>(vCB[i]);
1524 if (pBut && pBut->getType() == CCtrlBaseButton::RadioButton)
1525 {
1526 pBut->setPushed (false);
1527 }
1528 }
1529 }
1530 };
1531 REGISTER_ACTION_HANDLER (CAHResetPushed, "reset_pushed");
1532
1533
1534
1535
1536
1537 // Launch the game given a slot (slot is reference to the character summaries
1538 // ------------------------------------------------------------------------------------------------
1539 class CAHLaunchGame : public IActionHandler
1540 {
1541 public:
1542 virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
1543 {
1544 // Get the edit/play mode
1545 string sEditMode = getParam(Params, "edit_mode");
1546 bool wantsEditMode = false;
1547 CInterfaceExprValue result;
1548 bool wantsNewScenario = false;
1549
1550 if (CInterfaceExpr::eval(sEditMode, result))
1551 {
1552 wantsEditMode = (result.getInteger() == 1) || (result.getInteger() == 2);
1553 wantsNewScenario = (result.getInteger() == 2);
1554 }
1555
1556 CInterfaceManager *im = CInterfaceManager::getInstance();
1557 if (wantsEditMode)
1558 {
1559 // full patch needed for edition, warn the client
1560 if (AvailablePatchs != 0)
1561 {
1562 if (im->isInGame())
1563 {
1564 inGamePatchUncompleteWarning();
1565 }
1566 else
1567 {
1568 im->messageBoxWithHelp(CI18N::get("uiBGD_FullPatchNeeded"), "ui:outgame");
1569 }
1570 return;
1571 }
1572 }
1573
1574 // Get the player selected slot
1575 string sSlot = getParam(Params, "slot");
1576 if (sSlot != "ingame_auto")
1577 {
1578 CInterfaceExprValue result;
1579 if (!CInterfaceExpr::eval(sSlot, result))
1580 return;
1581 PlayerSelectedSlot = (uint8)result.getInteger();
1582 if (PlayerSelectedSlot >= CharacterSummaries.size())
1583 return;
1584
1585 ClientCfg.writeInt("SelectedSlot",PlayerSelectedSlot);
1586 if (ClientCfg.SaveConfig)
1587 ClientCfg.ConfigFile.save();
1588 }
1589
1590
1591 /*
1592 static volatile bool isMainlandCharacter = false; // TMP until we can get this info
1593 if (isMainlandCharacter)
1594 {
1595 nlassert(0); // use id="message_box" !!!
1596 if (AvailablePatchs != 0)
1597 {
1598 im->messageBoxWithHelp(CI18N::get("uiBGD_MainlandCharFullPatchNeeded"), "ui:outgame");
1599 }
1600 return;
1601 }
1602 */
1603
1604
1605 // Select the right sheet to create the user character.
1606 ClientCfg.UserSheet = CharacterSummaries[PlayerSelectedSlot].SheetId.toString();
1607
1608 // If the user wants to enter its editing session, get the ring server to Far TP to.
1609 if (wantsEditMode)
1610 {
1611
1612 if (wantsNewScenario)
1613 {
1614 CSessionBrowserImpl &sb = CSessionBrowserImpl::getInstance();
1615 sb.init(NULL);
1616 sb.closeEditSession(sb.getCharId());
1617 sb.waitOneMessage(CSessionBrowserImpl::getMessageName("on_invokeResult"));
1618 }
1619 if (FarTP.requestFarTPToSession( (TSessionId)0, PlayerSelectedSlot, CFarTP::LaunchEditor, false ))
1620 {
1621 WaitServerAnswer = true; // prepare to receive the character messages
1622 }
1623
1624 // // If the player clicked 'Launch Editor', there was no CONNECTION:SELECT_CHAR sent yet,
1625 // // so don't wait for the EGS to acknowledge our quit message as he does not know our character
1626 // LoginSM.pushEvent(CLoginStateMachine::ev_ingame_return);
1627
1628 return;
1629 }
1630
1631 // Send CONNECTION:SELECT_CHAR
1632 CBitMemStream out;
1633 nlverify( GenericMsgHeaderMngr.pushNameToStream ("CONNECTION:SELECT_CHAR", out) );
1634 //nlinfo("impulseCallBack : CONNECTION:SELECT_CHAR '%d' sent.", PlayerSelectedSlot);
1635
1636
1637 CSelectCharMsg SelectCharMsg;
1638 SelectCharMsg.c = (uint8)PlayerSelectedSlot;
1639 out.serial (SelectCharMsg);
1640 if (!ClientCfg.Local/*ace!ClientCfg.Light*/)
1641 {
1642 NetMngr.push(out);
1643 NetMngr.send(NetMngr.getCurrentServerTick());
1644 }
1645
1646 //PlayerWantToGoInGame = true;
1647
1648 // CBitMemStream out2;
1649 // if(GenericMsgHeaderMngr.pushNameToStream("CONNECTION:ENTER", out2))
1650 // {
1651 // NetMngr.push(out2);
1652 // nlinfo("impulseCallBack : CONNECTION:ENTER sent");
1653 // }
1654 // else
1655 // nlwarning("unknown message name : 'CONNECTION:ENTER'.");
1656
1657 WaitServerAnswer = true;
1658 if (ClientCfg.Local)
1659 serverReceivedReady = true;
1660 }
1661 };
1662 REGISTER_ACTION_HANDLER (CAHLaunchGame, "launch_game");
1663
1664
1665 // Ask the server to create a character
1666 // ------------------------------------------------------------------------------------------------
1667 class CAHAskCreateChar : public IActionHandler
1668 {
1669 public:
1670 virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
1671 {
1672 CInterfaceManager *pIM = CInterfaceManager::getInstance();
1673
1674 // Create the message for the server to create the character.
1675 CBitMemStream out;
1676 if (!GenericMsgHeaderMngr.pushNameToStream("CONNECTION:CREATE_CHAR", out))
1677 {
1678 nlwarning ("don't know message name CONNECTION:CREATE_CHAR");
1679 return;
1680 }
1681
1682 // Setup the name
1683 string sEditBoxPath = getParam (Params, "name");
1684 string sFirstName = "NotSet";
1685 string sSurName = "NotSet";
1686 CGroupEditBox *pGEB = dynamic_cast<CGroupEditBox*>(CWidgetManager::getInstance()->getElementFromId(sEditBoxPath));
1687 if (pGEB != NULL)
1688 sFirstName = pGEB->getInputString();
1689 else
1690 nlwarning ("can't get edit box name : %s",sEditBoxPath.c_str());
1691
1692 // Build the character summary from the database branch ui:temp:char3d
1693 CCharacterSummary CS;
1694 string sCharSumPath = getParam(Params, "charsum");
1695 SCharacter3DSetup::setupCharacterSummaryFromDB(CS, sCharSumPath);
1696 CS.Mainland = MainlandSelected;
1697 CS.Name = ucstring::makeFromUtf8(sFirstName); // FIXME: UTF-8 (serial)
1698 //CS.Surname = sSurName;
1699
1700 // Create the message to send to the server from the character summary
1701 CCreateCharMsg CreateCharMsg;
1702
1703 CreateCharMsg.setupFromCharacterSummary(CS);
1704
1705 // Slot
1706 {
1707 string sSlot = getParam(Params, "slot");
1708
1709 CInterfaceExprValue result;
1710 if (!CInterfaceExpr::eval(sSlot, result))
1711 return;
1712
1713 CreateCharMsg.Slot = (uint8)result.getInteger();
1714
1715 NLGUI::CDBManager::getInstance()->getDbProp("UI:SELECTED_SLOT")->setValue32(PlayerSelectedSlot);
1716 }
1717
1718 // Setup the new career
1719 string sCaracBasePath = getParam (Params, "caracs");
1720 CreateCharMsg.NbPointFighter = (uint8)NLGUI::CDBManager::getInstance()->getDbProp(sCaracBasePath+"FIGHT")->getValue32();
1721 CreateCharMsg.NbPointCaster = (uint8)NLGUI::CDBManager::getInstance()->getDbProp(sCaracBasePath+"MAGIC")->getValue32();
1722 CreateCharMsg.NbPointCrafter = (uint8)NLGUI::CDBManager::getInstance()->getDbProp(sCaracBasePath+"CRAFT")->getValue32();
1723 CreateCharMsg.NbPointHarvester = (uint8)NLGUI::CDBManager::getInstance()->getDbProp(sCaracBasePath+"FORAGE")->getValue32();
1724
1725 // Setup starting point
1726 string sLocationPath = getParam(Params, "loc");
1727 {
1728 CreateCharMsg.StartPoint = RYZOM_STARTING_POINT::borea;
1729
1730 CCDBNodeLeaf *pNL = NLGUI::CDBManager::getInstance()->getDbProp (sLocationPath, false);
1731 if (pNL != NULL)
1732 CreateCharMsg.StartPoint = (RYZOM_STARTING_POINT::TStartPoint)(pNL->getValue64());
1733 else
1734 nlwarning(("Can't read starting point from the database : " + sLocationPath).c_str());
1735
1736 if (CS.People == EGSPD::CPeople::Fyros)
1737 CreateCharMsg.StartPoint= (RYZOM_STARTING_POINT::TStartPoint)(((uint8)CreateCharMsg.StartPoint) + ((uint8)RYZOM_STARTING_POINT::fyros_start));
1738 else if (CS.People == EGSPD::CPeople::Matis)
1739 CreateCharMsg.StartPoint= (RYZOM_STARTING_POINT::TStartPoint)(((uint8)CreateCharMsg.StartPoint) + ((uint8)RYZOM_STARTING_POINT::matis_start));
1740 else if (CS.People == EGSPD::CPeople::Tryker)
1741 CreateCharMsg.StartPoint= (RYZOM_STARTING_POINT::TStartPoint)(((uint8)CreateCharMsg.StartPoint) + ((uint8)RYZOM_STARTING_POINT::tryker_start));
1742 else // if (CS.People == EGSPD::CPeople::Zorai)
1743 CreateCharMsg.StartPoint= (RYZOM_STARTING_POINT::TStartPoint)(((uint8)CreateCharMsg.StartPoint) + ((uint8)RYZOM_STARTING_POINT::zorai_start));
1744
1745 }
1746
1747 // Send the message to the server
1748 CreateCharMsg.serialBitMemStream (out);
1749 if (!ClientCfg.Local/*!ClientCfg.Light*/)
1750 {
1751 noUserChar = userChar = false;
1752
1753 NetMngr.push(out);
1754 NetMngr.send(NetMngr.getCurrentServerTick());
1755
1756 //nlinfo("impulseCallBack : CONNECTION:CREATE_CHAR sent");
1757 CreateCharMsg.dump();
1758 }
1759 else
1760 {
1761 userChar = true;
1762 if (CharacterSummaries.size() < 5)
1763 CharacterSummaries.push_back(CS);
1764 }
1765 WaitServerAnswer = true;
1766 }
1767 };
1768 REGISTER_ACTION_HANDLER (CAHAskCreateChar, "ask_create_char");
1769
1770
1771
1772 // Ask the server to delete a character
1773 // ------------------------------------------------------------------------------------------------
1774 class CAHAskDeleteChar : public IActionHandler
1775 {
1776 public:
1777 virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
1778 {
1779 // Create the message for the server to create the character.
1780 CBitMemStream out;
1781 if (!GenericMsgHeaderMngr.pushNameToStream("CONNECTION:DELETE_CHAR", out))
1782 {
1783 nlwarning ("don't know message name CONNECTION:DELETE_CHAR");
1784 return;
1785 }
1786
1787 // Get the selected slot
1788 CInterfaceManager *pIM = CInterfaceManager::getInstance();
1789
1790 string sSlot = getParam(Params, "slot");
1791
1792 CInterfaceExprValue result;
1793 if (!CInterfaceExpr::eval(sSlot, result))
1794 return;
1795
1796 uint8 nSelectedSlot = (uint8)result.getInteger();
1797 if (nSelectedSlot >= CharacterSummaries.size())
1798 return;
1799
1800 out.serial (nSelectedSlot);
1801
1802 // Yoyo: delete the Local files. To avoid problem if recreate a character with same name.
1803 string playerName = CharacterSummaries[nSelectedSlot].Name.toUtf8();
1804 string playerDeletedFileName = buildPlayerNameForSaveFile(playerName);
1805 // Delete the 2 Local files
1806 pIM->deletePlayerConfig(playerDeletedFileName);
1807 pIM->deletePlayerKeys(playerDeletedFileName);
1808
1809 // Send the message to the server
1810 if (!ClientCfg.Local/*ace!ClientCfg.Light*/)
1811 {
1812 noUserChar = userChar = false;
1813 NetMngr.push(out);
1814 NetMngr.send(NetMngr.getCurrentServerTick());
1815
1816 //nlinfo("impulseCallBack : CONNECTION:DELETE_CHAR %d sent", nSelectedSlot);
1817 }
1818 else
1819 {
1820 if (nSelectedSlot < CharacterSummaries.size())
1821 CharacterSummaries.erase (CharacterSummaries.begin()+nSelectedSlot);
1822 if (CharacterSummaries.size() != 0)
1823 userChar = true;
1824 else
1825 noUserChar = true;
1826 }
1827 WaitServerAnswer = true;
1828 }
1829 };
1830 REGISTER_ACTION_HANDLER (CAHAskDeleteChar, "ask_delete_char");
1831
1832 // ------------------------------------------------------------------------------------------------
1833 string getTarget(CCtrlBase * /* ctrl */, const string &targetName)
1834 {
1835 string sTmp = targetName;
1836 std::vector<CInterfaceLink::CTargetInfo> targetsVector;
1837 CInterfaceLink::splitLinkTargets(sTmp, NULL, targetsVector);
1838
1839 CInterfaceLink::CTargetInfo &rTI = targetsVector[0];
1840
1841 CInterfaceElement *elem = rTI.Elem;
1842 if (!elem)
1843 {
1844 nlwarning("<CInterfaceExpr::getprop> : Element is NULL");
1845 return "";
1846 }
1847 const CReflectedProperty *pRP = CReflectSystem ::getProperty(elem->getReflectedClassName(), rTI.PropertyName);
1848
1849 if (pRP->Type == CReflectedProperty::String)
1850 return ((elem->*(pRP->GetMethod.GetString))());
1851 return "";
1852 }
1853
1854 #ifdef RYZOM_LUA_UCSTRING
1855 // ------------------------------------------------------------------------------------------------
1856 ucstring getUCTarget(CCtrlBase * /* ctrl */, const string &targetName)
1857 {
1858 string sTmp = targetName;
1859 std::vector<CInterfaceLink::CTargetInfo> targetsVector;
1860 CInterfaceLink::splitLinkTargets(sTmp, NULL, targetsVector);
1861
1862 CInterfaceLink::CTargetInfo &rTI = targetsVector[0];
1863
1864 CInterfaceElement *elem = rTI.Elem;
1865 if (!elem)
1866 {
1867 nlwarning("<CInterfaceExpr::getprop> : Element is NULL");
1868 return ucstring(""); // TODO: UTF-8 Lua
1869 }
1870 const CReflectedProperty *pRP = elem->getReflectedProperty(rTI.PropertyName);
1871
1872 if (pRP->Type == CReflectedProperty::UCString)
1873 return ((elem->*(pRP->GetMethod.GetUCString))());
1874 return ucstring(""); // TODO: UTF-8 Lua
1875 }
1876 #endif
1877
1878 /*// Ask the server to rename a character
1879 // ------------------------------------------------------------------------------------------------
1880 class CAHAskRenameChar : public IActionHandler
1881 {
1882 public:
1883 virtual void execute (CCtrlBase *pCaller, const string &Params)
1884 {
1885 string sName = getTarget(NULL,getParam(Params, "name"));
1886 string sSurname = getTarget(NULL,getParam(Params, "surname"));
1887
1888 string sDBSlot = getParam(Params, "dbslot");
1889
1890 CInterfaceManager *pIM = CInterfaceManager::getInstance();
1891 uint8 nSelectedSlot = (uint8)NLGUI::CDBManager::getInstance()->getDbProp(sDBSlot,false)->getValue32();
1892
1893 if (nSelectedSlot > CharacterSummaries.size())
1894 return;
1895
1896 // Create the message for the server to create the character.
1897 CBitMemStream out;
1898 if (!GenericMsgHeaderMngr.pushNameToStream("CONNECTION:RENAME_CHAR", out))
1899 {
1900 nlwarning ("don't know message name CONNECTION:RENAME_CHAR");
1901 return;
1902 }
1903
1904 // Get the selected slot
1905 out.serial (nSelectedSlot);
1906 out.serial (sName);
1907 out.serial (sSurname);
1908
1909 // Send the message to the server
1910 if (!ClientCfg.Light)
1911 {
1912 noUserChar = userChar = false;
1913 NetMngr.push (out);
1914 NetMngr.send (NetMngr.getCurrentServerTick());
1915
1916 nldebug("impulseCallBack : CONNECTION:RENAME_CHAR sent");
1917
1918 // Wait for the character message which describe all the characters on a server
1919 while (!noUserChar && !userChar)
1920 {
1921 //NetMngr.waitForServer();
1922 NetMngr.update();
1923 NetMngr.send();
1924 nlSleep(100);
1925 }
1926 }
1927 else
1928 {
1929 CharacterSummaries[nSelectedSlot].FirstName = sName;
1930 CharacterSummaries[nSelectedSlot].Surname = sSurname;
1931 }
1932 }
1933 };
1934 REGISTER_ACTION_HANDLER (CAHAskRenameChar, "ask_rename_char");
1935 */
1936
1937 // Ask the server if the name is not already used
1938 // ------------------------------------------------------------------------------------------------
1939 class CAHAskValidName : public IActionHandler
1940 {
1941 public:
1942 virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
1943 {
1944 string sTarget = getParam(Params, "target");
1945 string sDBLink = getParam(Params, "dblink");
1946 CharNameValidDBLink = sDBLink;
1947
1948 #ifdef RYZOM_LUA_UCSTRING
1949 string sName = getUCTarget(NULL,sTarget).toUtf8(); // TODO: UTF-8 Lua
1950 #else
1951 string sName = getTarget(NULL, sTarget);
1952 #endif
1953
1954 CInterfaceManager *pIM = CInterfaceManager::getInstance();
1955 if (sName.empty())
1956 {
1957 NLGUI::CDBManager::getInstance()->getDbProp(sDBLink,false)->setValue32(0);
1958 return;
1959 }
1960
1961 // Ask the server
1962 CharNameValid = true;
1963
1964 // PATCH DU BUG DE L'ESPACE !!!
1965 if (sName.find(' ') != ucstring::npos)
1966 CharNameValid = false;
1967 // PATCH DU BUG DE L'ESPACE !!!
1968
1969
1970 if (CharNameValid)
1971 {
1972 if (!ClientCfg.Local/*ace!ClientCfg.Light*/)
1973 {
1974
1975 CBitMemStream out;
1976 if (!GenericMsgHeaderMngr.pushNameToStream("CONNECTION:ASK_NAME", out))
1977 {
1978 nlwarning ("don't know message name CONNECTION:ASK_NAME");
1979 return;
1980 }
1981
1982 CCheckNameMsg checkNameMsg;
1983 checkNameMsg.Name = sName;
1984 checkNameMsg.HomeSessionId = MainlandSelected;
1985 checkNameMsg.serialBitMemStream(out);
1986
1987 NewKeysCharNameWanted = sName;
1988 // append shard name
1989 for(uint k = 0; k < Mainlands.size(); ++k)
1990 {
1991 if (Mainlands[k].Id == MainlandSelected)
1992 {
1993 // extract name from mainland
1994 /*ucstring::size_type first = Mainlands[k].Name.find('('); // OLD
1995 ucstring::size_type last = Mainlands[k].Name.find(')');// OLD
1996 if (first != ucstring::npos && last != ucstring::npos && first < last)// OLD
1997 {
1998 NewKeysCharNameWanted += Mainlands[k].Name.substr(first, last - first + 1);
1999 }*/
2000 NewKeysCharNameWanted += ('(' + Mainlands[k].Name.toUtf8() + ')');
2001 break;
2002 }
2003 }
2004
2005 NewKeysCharNameValidated.clear();
2006
2007 NetMngr.push(out);
2008 NetMngr.send(NetMngr.getCurrentServerTick());
2009
2010 //nlinfo("impulseCallBack : CONNECTION:ASK_NAME sent");
2011
2012 // Wait for the valid character name message
2013 CharNameValidArrived = false;
2014 }
2015 else
2016 {
2017
2018 CharNameValid = true;
2019 CharNameValidArrived = true;
2020
2021 for (uint i = 0; i < CharacterSummaries.size(); ++i)
2022 {
2023 string ls = CharacterSummaries[i].Name.toString();
2024 if (ls == sName)
2025 CharNameValid = false;
2026 }
2027 }
2028 }
2029 else
2030 {
2031 CharNameValidArrived = true;
2032 }
2033 WaitServerAnswer = true;
2034 }
2035 };
2036 REGISTER_ACTION_HANDLER (CAHAskValidName, "ask_valid_name");
2037
2038 // ------------------------------------------------------------------------------------------------
2039 class CAHPlaySound : public IActionHandler
2040 {
2041 public:
2042 virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
2043 {
2044 string sName = getParam(Params, "name");
2045 TStringId id = CStringMapper::map(sName);
2046 if (SoundMngr != NULL)
2047 SoundMngr->spawnSource(id,CVector(0,0,0));
2048 }
2049 };
2050 REGISTER_ACTION_HANDLER (CAHPlaySound, "play_sound");
2051
2052 // ------------------------------------------------------------------------------------------------
2053 class CAHPlayMusicOutgame : public IActionHandler
2054 {
2055 public:
2056 virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
2057 {
2058 // get the name of the wanted music
2059 string sName = getParam(Params, "name");
2060 bool async;
2061 fromString(getParam(Params, "async"), async);
2062
2063 // if empty name, return to default mode
2064 if (sName.empty())
2065 sName = ClientCfg.EmptySlotMusic;
2066
2067 // change the music
2068 SoundGlobalMenu.setMusic(sName, async);
2069 }
2070 };
2071 REGISTER_ACTION_HANDLER (CAHPlayMusicOutgame, "play_music_outgame");
2072
2073 // ------------------------------------------------------------------------------------------------
2074 class CAHRepeatUntil : public IActionHandler
2075 {
2076 public:
2077 virtual void execute (CCtrlBase *pCaller, const string &Params)
2078 {
2079 string sProc = getParam(Params, "proc");
2080 string sCond = getParam(Params, "cond");
2081 CInterfaceManager *pIM = CInterfaceManager::getInstance();
2082
2083 for(;;)
2084 {
2085 vector<string> p;
2086 p.push_back(sProc);
2087 CWidgetManager::getInstance()->runProcedure(sProc, pCaller, p);
2088
2089 CInterfaceExprValue result;
2090 if (CInterfaceExpr::eval(sCond, result))
2091 {
2092 if (result.getBool())
2093 break;
2094 }
2095 else
2096 {
2097 break;
2098 }
2099 }
2100
2101 }
2102 };
2103 REGISTER_ACTION_HANDLER (CAHRepeatUntil, "repeatuntil");
2104
2105
2106 // ------------------------------------------------------------------------------------------------
2107 class CAHDispInfo : public IActionHandler
2108 {
2109 public:
2110 virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
2111 {
2112 string sStr = getParam(Params, "str");
2113 string sVal = getParam(Params, "val");
2114
2115 string res;
2116
2117 CInterfaceExprValue result;
2118 if (CInterfaceExpr::eval(sStr, result))
2119 {
2120 if (result.toString())
2121 {
2122 res += result.getString();
2123 }
2124 }
2125 if (CInterfaceExpr::eval(sVal, result))
2126 {
2127 if (result.toString())
2128 {
2129 res += result.getString();
2130 }
2131 }
2132
2133 nlinfo(res.c_str());
2134 }
2135 };
2136 REGISTER_ACTION_HANDLER (CAHDispInfo, "disp_info");
2137
2138
2139 // ***************************************************************************
2140 class CAHInitMainlandList : public IActionHandler
2141 {
2142 public:
2143
2144 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
2145 {
2146 //CInterfaceManager *pIM = CInterfaceManager::getInstance();
2147
2148 CInterfaceGroup *pList = dynamic_cast<CInterfaceGroup*>(CWidgetManager::getInstance()->getElementFromId(GROUP_LIST_MAINLAND));
2149 if (pList == NULL)
2150 {
2151 nlwarning("element " GROUP_LIST_MAINLAND " not found probably bad outgame.xml");
2152 return;
2153 }
2154
2155 CInterfaceGroup *pPrevLine = NULL;
2156 for(uint i = 0; i < Mainlands.size(); i++)
2157 {
2158 vector< pair < string, string > > params;
2159 params.clear();
2160 params.push_back(pair<string,string>("id", toString(Mainlands[i].Id)));
2161 if (i>0)
2162 params.push_back(pair<string,string>("posref", "BL TL"));
2163
2164 CInterfaceGroup *pNewLine = CWidgetManager::getInstance()->getParser()->createGroupInstance("t_mainland", GROUP_LIST_MAINLAND, params);
2165 if (pNewLine != NULL)
2166 {
2167 CViewBase *pVBon = pNewLine->getView("online");
2168 CViewBase *pVBoff = pNewLine->getView("offline");
2169 if ((pVBon != NULL) && (pVBoff != NULL))
2170 {
2171 pVBon->setActive(Mainlands[i].Online);
2172 pVBoff->setActive(!Mainlands[i].Online);
2173 }
2174
2175 CViewText *pVT = dynamic_cast<CViewText*>(pNewLine->getView("name"));
2176 if (pVT != NULL)
2177 {
2178 std::string str = Mainlands[i].Name.toUtf8() + " " + Mainlands[i].Description.toUtf8();
2179 pVT->setTextLocalized(str, false);
2180 }
2181
2182 // Add to the list
2183 pNewLine->setParent(pList);
2184 pNewLine->setParentSize(pList);
2185 pNewLine->setParentPos(pPrevLine);
2186 pList->addGroup(pNewLine);
2187
2188 pPrevLine = pNewLine;
2189 }
2190 }
2191 // UI Patch
2192 if (!Mainlands.empty())
2193 {
2194 //choose default mainland from language code
2195 uint32 defaultMainland = 0;
2196 for(uint i = 0; i < Mainlands.size(); i++)
2197 {
2198 if( Mainlands[i].LanguageCode == ClientCfg.LanguageCode )
2199 {
2200 defaultMainland = i;
2201 break;
2202 }
2203 }
2204
2205 CCtrlButton *pCB = dynamic_cast<CCtrlButton*>(CWidgetManager::getInstance()->getElementFromId(GROUP_LIST_MAINLAND ":"+toString(Mainlands[defaultMainland].Id)+":but"));
2206 if (pCB != NULL)
2207 {
2208 pCB->setPushed(true);
2209 CAHManager::getInstance()->runActionHandler (pCB->getActionOnLeftClick(), pCB, pCB->getParamsOnLeftClick());
2210 }
2211 }
2212 pList->invalidateCoords();
2213 }
2214 };
2215 REGISTER_ACTION_HANDLER (CAHInitMainlandList, "init_mainland_list");
2216
2217
2218 // ***************************************************************************
2219 class CAHResetMainlandList : public IActionHandler
2220 {
2221 public:
2222
2223 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
2224 {
2225 //CInterfaceManager *pIM = CInterfaceManager::getInstance();
2226 CInterfaceGroup *pList = dynamic_cast<CInterfaceGroup*>(CWidgetManager::getInstance()->getElementFromId(GROUP_LIST_MAINLAND));
2227 pList->clearGroups();
2228 }
2229 };
2230 REGISTER_ACTION_HANDLER (CAHResetMainlandList, "reset_mainland_list");
2231
2232
2233 // ***************************************************************************
2234 class CAHMainlandSelect : public IActionHandler
2235 {
2236 virtual void execute (CCtrlBase *pCaller, const string &/* Params */)
2237 {
2238 nlinfo("CAHMainlandSelect called");
2239
2240 CInterfaceManager *pIM = CInterfaceManager::getInstance();
2241
2242 CCtrlButton *pCB = NULL;
2243 // Unselect
2244 if (MainlandSelected.asInt() != 0)
2245 {
2246 pCB = dynamic_cast<CCtrlButton*>(CWidgetManager::getInstance()->getElementFromId(GROUP_LIST_MAINLAND ":"+toString(MainlandSelected)+":but"));
2247 if (pCB != NULL)
2248 pCB->setPushed(false);
2249 }
2250
2251 pCB = dynamic_cast<CCtrlButton*>(pCaller);
2252 if (pCB != NULL)
2253 {
2254 string name = pCB->getId();
2255 name = name.substr(0,name.rfind(':'));
2256 uint32 mainland;
2257 fromString(name.substr(name.rfind(':')+1,name.size()), mainland);
2258 MainlandSelected = (TSessionId)mainland;
2259
2260 pCB->setPushed(true);
2261 }
2262 }
2263 };
2264 REGISTER_ACTION_HANDLER (CAHMainlandSelect, "mainland_select");
2265
2266
2267 // ***************************************************************************
2268 class CAHInitKeysetList : public IActionHandler
2269 {
2270 public:
2271
2272
2273
2274 CInterfaceGroup *PrevLine;
2275 CInterfaceGroup *List;
2276 bool First;
2277
2278 CInterfaceGroup *buildTemplate(const std::string &templateName, const std::string &id)
2279 {
2280 vector< pair < string, string > > params;
2281 params.clear();
2282 params.push_back(pair<string,string>("id", id));
2283 if (!First)
2284 {
2285 params.push_back(pair<string,string>("posref", "BL TL"));
2286 }
2287 First = false;
2288 CInterfaceManager *pIM = CInterfaceManager::getInstance();
2289 return CWidgetManager::getInstance()->getParser()->createGroupInstance(templateName, GROUP_LIST_KEYSET, params);
2290 }
2291
2292 void addGroupInList(CInterfaceGroup *pNewLine)
2293 {
2294 if (!pNewLine) return;
2295 // Add to the list
2296 pNewLine->setParent(List);
2297 pNewLine->setParentSize(List);
2298 pNewLine->setParentPos(PrevLine);
2299 List->addGroup(pNewLine);
2300
2301 PrevLine = pNewLine;
2302 }
2303
2304 void addSeparator()
2305 {
2306 addGroupInList(buildTemplate("t_keyseparator", ""));
2307 }
2308
2309 // add a new keyset in the list
2310 void addKeySet(const std::string &filename, const std::string &name, const std::string tooltip)
2311 {
2312 nlassert(List);
2313 CInterfaceGroup *pNewLine = buildTemplate("t_keyset", toString(filename));
2314 if (pNewLine != NULL)
2315 {
2316 CViewText *pVT = dynamic_cast<CViewText*>(pNewLine->getView("name"));
2317 if (pVT != NULL)
2318 {
2319 pVT->setTextLocalized(name, false);
2320 }
2321
2322 CCtrlBase *pBut = pNewLine->getCtrl("but");
2323 if (pBut != NULL)
2324 {
2325 pBut->setDefaultContextHelp(tooltip);
2326 }
2327 addGroupInList(pNewLine);
2328 }
2329 }
2330
2331 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
2332 {
2333 NewKeysCharNameWanted.clear();
2334 NewKeysCharNameValidated.clear();
2335 GameKeySet = "keys.xml";
2336 RingEditorKeySet = "keys_r2ed.xml";
2337 First = true;
2338 PrevLine = NULL;
2339 CInterfaceManager *pIM = CInterfaceManager::getInstance();
2340
2341 List = dynamic_cast<CInterfaceGroup *>(CWidgetManager::getInstance()->getElementFromId(GROUP_LIST_KEYSET));
2342 if (List == NULL)
2343 {
2344 nlwarning("element " GROUP_LIST_KEYSET " not found probably bad outgame.xml");
2345 return;
2346 }
2347
2348 // built-in keysets
2349 CConfigFile::CVar *keySetVar = ClientCfg.ConfigFile.getVarPtr(KeySetVarName);
2350 sint wasdIndex = -1;
2351 sint zqsdIndex = -1;
2352 if (keySetVar && keySetVar->size() != 0)
2353 {
2354 for (uint k = 0; k < keySetVar->size(); ++k)
2355 {
2356 if (keySetVar->asString(k) == "zqsd") zqsdIndex = (sint) k;
2357 if (keySetVar->asString(k) == "wasd") wasdIndex = (sint) k;
2358
2359 std::string strId = "uiCP_KeysetName_" + keySetVar->asString(k);
2360 strFindReplace(strId, ".", "_");
2361 const string &keySetName = CI18N::get(strId);
2362 strId = "uiCP_KeysetTooltip_" + keySetVar->asString(k);
2363 strFindReplace(strId, ".", "_");
2364 if (CI18N::hasTranslation(strId))
2365 {
2366 const string &keySetTooltip = CI18N::get(strId);
2367 addKeySet(keySetVar->asString(k), keySetName, keySetTooltip);
2368 }
2369 }
2370 }
2371 else
2372 {
2373 nlwarning("'%s' var not found in config file, or list is empty, proposing default keyset only", KeySetVarName);
2374 std::string defaultKeySet = "keys";
2375 const string &keySetName = CI18N::get("uiCP_KeysetName_" + defaultKeySet);
2376 const string &keySetTooltip = CI18N::get("uiCP_KeysetTooltip_" + defaultKeySet);
2377 addKeySet(defaultKeySet, keySetName, keySetTooltip);
2378 }
2379
2380 // keyset from previous chars
2381 std::vector<std::string> savedFiles;
2382 CPath::getPathContent("save/", false, false, true, savedFiles);
2383 enum { GameKeys = 0x1, EditorKeys = 0x2 };
2384 typedef std::map<std::string, uint> TKeySetFileMap;
2385 TKeySetFileMap keySetFiles; // combination of 'GameKeys' & 'EditorKeys' flag for each character
2386 for (uint k = 0; k < savedFiles.size(); ++k)
2387 {
2388 if (testWildCard(CFile::getFilename(savedFiles[k]), "keys_*.xml"))
2389 {
2390 bool editorKeys = testWildCard(CFile::getFilename(savedFiles[k]), "keys_r2ed_*.xml");
2391 std::string baseName = CFile::getFilenameWithoutExtension(savedFiles[k]).substr(strlen(editorKeys ? "keys_r2ed_" : "keys_"));
2392 if(!keySetFiles.count(baseName)) keySetFiles[baseName] = 0;
2393 keySetFiles[baseName] |= editorKeys ? EditorKeys : GameKeys;
2394 }
2395 }
2396 //
2397 bool separatorAdded = false;
2398 if (!keySetFiles.empty())
2399 {
2400 for(TKeySetFileMap::iterator it = keySetFiles.begin(); it != keySetFiles.end(); ++it)
2401 {
2402 string name;
2403 if (ClientCfg.Local)
2404 {
2405 name = it->first;
2406 }
2407 else
2408 {
2409 // search matching utf-8 string name from character summaries
2410 for (uint k = 0; k < CharacterSummaries.size(); ++k)
2411 {
2412 if (it->first == buildPlayerNameForSaveFile(CharacterSummaries[k].Name.toUtf8()))
2413 {
2414 name = CharacterSummaries[k].Name.toUtf8();
2415 }
2416 }
2417 }
2418 if (!name.empty())
2419 {
2420 if (!separatorAdded)
2421 {
2422 addSeparator();
2423 separatorAdded = true;
2424 }
2425 addKeySet(it->first, it->first, CI18N::get(std::string("uiCP_KeysetImport") + (it->second & GameKeys ? "_Game" : "")
2426 + (it->second & EditorKeys ? "_Editor" : "")));
2427 }
2428 }
2429 }
2430
2431 // default to 'ZQSD' for French and Belgian keyboard, 'WASD' else
2432 bool wasd = !CSystemUtils::isAzertyKeyboard();
2433
2434 /*sint startIndex = wasd ? wasdIndex : zqsdIndex;
2435 if (startIndex == -1) startIndex = 0;
2436 */
2437 // TMP TMP : no way to have 2 keys for the same action for now -> default to 'arrows' setting.
2438 sint startIndex = 0;
2439 nlassert(startIndex >= 0);
2440 if (startIndex < (sint) List->getNumGroup())
2441 {
2442 CInterfaceGroup *gr = dynamic_cast<CInterfaceGroup *>(List->getGroup(startIndex));
2443 if (gr)
2444 {
2445 CCtrlButton *pCB = dynamic_cast<CCtrlButton*>(gr->getCtrl("but"));
2446 if (pCB != NULL)
2447 {
2448 pCB->setPushed(true);
2449 CAHManager::getInstance()->runActionHandler (pCB->getActionOnLeftClick(), pCB, pCB->getParamsOnLeftClick());
2450 }
2451 }
2452 }
2453 List->invalidateCoords();
2454 }
2455 };
2456 REGISTER_ACTION_HANDLER (CAHInitKeysetList, "init_keyset_list");
2457
2458
2459 // ***************************************************************************
2460 class CAHResetKeysetList : public IActionHandler
2461 {
2462 public:
2463
2464 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
2465 {
2466 //CInterfaceManager *pIM = CInterfaceManager::getInstance();
2467 CInterfaceGroup *pList = dynamic_cast<CInterfaceGroup*>(CWidgetManager::getInstance()->getElementFromId(GROUP_LIST_KEYSET));
2468 pList->clearGroups();
2469 }
2470 };
2471 REGISTER_ACTION_HANDLER (CAHResetKeysetList, "reset_keyset_list");
2472
2473
2474 // ***************************************************************************
2475 class CAHResetKeysetSelect : public IActionHandler
2476 {
2477 public:
2478 std::string getIdPostFix(const std::string fullId)
2479 {
2480 std::string::size_type pos = fullId.find_last_of(":");
2481 if (pos != std::string::npos)
2482 {
2483 return fullId.substr(pos + 1);
2484 }
2485 return "";
2486 }
2487 virtual void execute (CCtrlBase *pCaller, const string &/* Params */)
2488 {
2489 if (!pCaller) return;
2490 // 'unpush' all groups but the caller
2491 //
2492 struct CUnpush : public CInterfaceElementVisitor
2493 {
2494 CCtrlBase *Ref;
2495 virtual void visitCtrl(CCtrlBase *ctrl)
2496 {
2497 if (ctrl == Ref) return;
2498 CCtrlBaseButton *but = dynamic_cast<CCtrlBaseButton *>(ctrl);
2499 if (but)
2500 {
2501 but->setPushed(false);
2502 }
2503 }
2504 };
2505 CInterfaceManager *pIM = CInterfaceManager::getInstance();
2506 CInterfaceGroup * list = dynamic_cast<CInterfaceGroup *>(CWidgetManager::getInstance()->getElementFromId(GROUP_LIST_KEYSET));
2507 if (list)
2508 {
2509 CUnpush unpusher;
2510 unpusher.Ref = pCaller;
2511 list->visit(&unpusher);
2512 }
2513 CCtrlBaseButton *but = dynamic_cast<CCtrlBaseButton *>(pCaller);
2514 if (but)
2515 {
2516 but->setPushed(true);
2517 }
2518 //
2519 GameKeySet = "keys.xml";
2520 RingEditorKeySet = "keys_r2ed.xml";
2521 if (!pCaller->getParent()) return;
2522 // compute the 2 filenames from the id
2523 // if id is in the built-in keysets :
2524 CConfigFile::CVar *keySetVar = ClientCfg.ConfigFile.getVarPtr(KeySetVarName);
2525 if (keySetVar && keySetVar->size() != 0)
2526 {
2527 for (uint k = 0; k < keySetVar->size(); ++k)
2528 {
2529 std::string id = getIdPostFix(pCaller->getParent()->getId());
2530 if (keySetVar->asString(k) == id)
2531 {
2532 GameKeySet = "keys" + string(id.empty() ? "" : "_") + id + ".xml";
2533 RingEditorKeySet = "keys_r2ed" + string(id.empty() ? "" : "_") + id + ".xml";
2534 return;
2535 }
2536 }
2537 }
2538 // ... else maybe from a previous character ?
2539 if (CFile::isExists("save/keys_" + getIdPostFix(pCaller->getParent()->getId()) + ".xml") )
2540 {
2541 GameKeySet = "keys_" + getIdPostFix(pCaller->getParent()->getId()) + ".xml";
2542 }
2543 if (CFile::isExists("save/keys_r2ed_" + getIdPostFix(pCaller->getParent()->getId()) + ".xml") )
2544 {
2545 RingEditorKeySet = "keys_r2ed_" + getIdPostFix(pCaller->getParent()->getId()) + ".xml";
2546 }
2547 // NB : key file will be copied for real when the new 'character summary' is
2548
2549 }
2550 };
2551 REGISTER_ACTION_HANDLER (CAHResetKeysetSelect, "keyset_select");
2552
2553
2554
2555
2556
2557 // *************************** SCENARIO CONTROL WINDOW ***********************
2558 // ***************************************************************************
2559 // helper function for "setScenarioInformation"
2560 static void setTextField(CInterfaceGroup* scenarioWnd, const std::string &uiName, const std::string &text)
2561 {
2562 CInterfaceElement *result = scenarioWnd->findFromShortId(uiName);
2563 if(result)
2564 {
2565 CViewText* viewText = dynamic_cast<CViewText*>(result);
2566 if(viewText)
2567 viewText->setTextLocalized(text, false);
2568 CGroupEditBox* editBox = dynamic_cast<CGroupEditBox*>(result);
2569 if(editBox)
2570 editBox->setInputString(text);
2571
2572 }
2573 }
2574 // helper function for "setScenarioInformation"
2575 static void setTextField(CInterfaceGroup* scenarioWnd, const std::string &uiName, const ucstring &text) // TODO: UTF-8 Lua
2576 {
2577 setTextField(scenarioWnd, uiName, text.toUtf8());
2578 }
2579 // helper function for "setScenarioInformation"
2580 static std::string fieldLookup(const vector< pair< string, string > > &values, const std::string &id)
2581 {
2582 for(uint i=0; i<values.size(); i++)
2583 {
2584 if (values[i].first == id) return values[i].second;
2585 }
2586 return "--";
2587 }
2588 //
2589 static void setScenarioInformation(CInterfaceGroup* scenarioWnd, const string scenarioName)
2590 {
2591 vector< pair< string, string > > values;
2592 if(R2::getEditor().isInitialized())
2593 {
2594 values = R2::getEditor().getDMC().getEditionModule().getScenarioHeader();
2595 }
2596 else
2597 {
2598 R2::CScenarioValidator sv;
2599 std::string md5, signature;
2600 sv.setScenarioToLoad(scenarioName, values, md5, signature, false);
2601 }
2602 //
2603 setTextField(scenarioWnd, "rules_value_text", fieldLookup(values, "Rules"));
2604 uint levelRange = 0;
2605 uint32 nLevel;
2606 fromString(fieldLookup(values, "Level"), nLevel);
2607 switch(nLevel)
2608 {
2609 case 20: levelRange = 0; break;
2610 case 50: levelRange = 1; break;
2611 case 100: levelRange = 2; break;
2612 case 150: levelRange = 3; break;
2613 case 200: levelRange = 4; break;
2614 case 250: levelRange = 5; break;
2615 }
2616 setTextField(scenarioWnd, "level_value_text", CI18N::get("uiRAP_Level" + toString(levelRange)));
2617 setTextField(scenarioWnd, "language_value_text", CI18N::get("uiR2ED" + fieldLookup(values, "Language")));
2618 setTextField(scenarioWnd, "type_value_text", CI18N::get("uiR2ED" + fieldLookup(values, "Type")));
2619 setTextField(scenarioWnd, "edit_small_description", fieldLookup(values, "ShortDescription"));
2620 if(R2::getEditor().isInitialized())
2621 {
2622 setTextField(scenarioWnd, "scenario_value_text", "'" + fieldLookup(values, "Title") + "'");
2623 }
2624 }
2625
2626
2627 void getChildrenControls(CInterfaceGroup* group, std::vector<CCtrlBase*> & controls)
2628 {
2629 for(uint i=0; i<group->getGroups().size(); i++)
2630 getChildrenControls(group->getGroups()[i], controls);
2631
2632 for(uint i=0; i<group->getControls().size(); i++)
2633 controls.push_back(group->getControls()[i]);
2634 }
2635
2636 inline void setToggleButton(CInterfaceGroup* scenarioWnd, const string & buttonName, bool pushed)
2637 {
2638 CInterfaceElement * result = scenarioWnd->findFromShortId(buttonName);
2639 if(result)
2640 {
2641 CInterfaceGroup * group = dynamic_cast<CInterfaceGroup*>(result);
2642 if(group)
2643 {
2644 result = group->findFromShortId(string("toggle_butt"));
2645 if(result)
2646 {
2647 CCtrlBaseButton * baseButton = dynamic_cast<CCtrlBaseButton*>(result);
2648 if(baseButton)
2649 baseButton->setPushed(!pushed);
2650 }
2651 }
2652 }
2653 }
2654
2655
2656 class CAHScenarioControl : public IActionHandler
2657 {
2658 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
2659 {
2660 nlinfo("CAHScenarioControl called");
2661
2662 CInterfaceManager *pIM = CInterfaceManager::getInstance();
2663 CInterfaceGroup* scenarioWnd = dynamic_cast<CInterfaceGroup*>(CWidgetManager::getInstance()->getElementFromId("ui:interface:r2ed_scenario_control"));
2664 if(!scenarioWnd) return;
2665
2666 // -------- active some groups in function of Ryzom mode or Edition/Animation mode ----
2667 // active team toggle button?
2668 CInterfaceElement *result = scenarioWnd->findFromShortId(string("invite_team"));
2669 if(result)
2670 {
2671 CInterfaceGroup* groupTeam = dynamic_cast<CInterfaceGroup*>(result);
2672 if(groupTeam)
2673 {
2674 bool team = !(R2::getEditor().isInitialized());
2675 if(team)
2676 team = (NLGUI::CDBManager::getInstance()->getDbProp("SERVER:USER:TEAM_MEMBER")->getValue8())!=0;
2677 groupTeam->setActive(team);
2678 }
2679 }
2680
2681 // set scenario name label
2682 result = scenarioWnd->findFromShortId(string("current_scenario_label_text"));
2683 if(result)
2684 {
2685 CViewText* viewText = dynamic_cast<CViewText*>(result);
2686 if(viewText)
2687 {
2688 viewText->setTextLocalized(R2::getEditor().isInitialized() ? "uiR2EDScenarioName" : "uiR2EDScenarioFileName", true);
2689 }
2690 }
2691
2692 // ok button tranlation
2693 result = scenarioWnd->findFromShortId(string("ok_button"));
2694 if(result)
2695 {
2696 CCtrlTextButton* okButton = dynamic_cast<CCtrlTextButton*>(result);
2697 if(okButton)
2698 {
2699 if(R2::getEditor().getAccessMode()!=R2::CEditor::AccessDM)
2700 okButton->setHardText(CI18N::get("uiR2EDLaunchScenario"));
2701 else
2702 okButton->setHardText(CI18N::get("uiR2EDApplyScenarioFilters"));
2703 }
2704 }
2705
2706 // init current scenario name and parameters
2707 if(!R2::getEditor().isInitialized())
2708 {
2709 ScenarioFileName.clear();
2710
2711 // empty scenario
2712 CInterfaceElement *result = scenarioWnd->findFromShortId(string("scenario_value_text"));
2713 if(result)
2714 {
2715 CViewText* viewText= dynamic_cast<CViewText*>(result);
2716
2717 if(viewText)
2718 viewText->setText(std::string());
2719 }
2720 }
2721 setScenarioInformation(scenarioWnd, "");
2722
2723 // hide description and information?
2724 result = scenarioWnd->findFromShortId(string("scenario_info_prop"));
2725 if(result)
2726 result->setActive(R2::getEditor().isInitialized());
2727
2728 result = scenarioWnd->findFromShortId(string("description_gr"));
2729 if(result)
2730 result->setActive(R2::getEditor().isInitialized());
2731
2732 // mainlands list
2733 result = scenarioWnd->findFromShortId(string("shards"));
2734 if(result)
2735 {
2736 CGroupList * shardList = dynamic_cast<CGroupList*>(result);
2737 if(shardList)
2738 {
2739 shardList->deleteAllChildren();
2740
2741 for(uint i = 0; i < Mainlands.size(); i++)
2742 {
2743 vector< pair < string, string > > params;
2744 params.clear();
2745 params.push_back(pair<string,string>("id", toString(Mainlands[i].Id)));
2746 params.push_back(pair<string,string>("w", "1024"));
2747 params.push_back(pair<string,string>("tooltip", "uiRingFilterShard"));
2748 CInterfaceGroup *toggleGr = CWidgetManager::getInstance()->getParser()->createGroupInstance("label_toggle_button", shardList->getId(), params);
2749 shardList->addChild(toggleGr);
2750 // set unicode name
2751 CViewText *shardName = dynamic_cast<CViewText *>(toggleGr->getView("button_text"));
2752 if (shardName)
2753 {
2754 shardName->setTextLocalized(Mainlands[i].Name.toUtf8(), false);
2755 }
2756 }
2757 }
2758 }
2759
2760 // show/display "back" button
2761 result = scenarioWnd->findFromShortId(string("load_button"));
2762 if(result)
2763 {
2764 CCtrlBaseButton * loadB = dynamic_cast<CCtrlBaseButton *>(result);
2765 if(loadB)
2766 {
2767 loadB->setActive(!R2::getEditor().isInitialized());
2768 }
2769 }
2770
2771 // fill toggle buttons
2772 if(R2::getEditor().getAccessMode()==R2::CEditor::AccessDM)
2773 {
2774 CSessionBrowserImpl & sessionBrowser = CSessionBrowserImpl::getInstance();
2775 sessionBrowser.getSessionInfo(sessionBrowser.getCharId(), R2::getEditor().getDMC().getEditionModule().getCurrentAdventureId());
2776
2777 if(sessionBrowser.waitOneMessage(sessionBrowser.getMessageName("on_sessionInfoResult")))
2778 {
2779 TRaceFilter & raceFilter = sessionBrowser._LastRaceFilter;
2780 setToggleButton(scenarioWnd, "fyros", raceFilter.checkEnumValue(TRaceFilterEnum::rf_fyros));
2781 setToggleButton(scenarioWnd, "matis", raceFilter.checkEnumValue(TRaceFilterEnum::rf_matis));
2782 setToggleButton(scenarioWnd, "tryker", raceFilter.checkEnumValue(TRaceFilterEnum::rf_tryker));
2783 setToggleButton(scenarioWnd, "zorai", raceFilter.checkEnumValue(TRaceFilterEnum::rf_zorai));
2784
2785 TReligionFilter & religionFilter = sessionBrowser._LastReligionFilter;
2786 setToggleButton(scenarioWnd, "kami", religionFilter.checkEnumValue(TReligionFilterEnum::rf_kami));
2787 setToggleButton(scenarioWnd, "karavan", religionFilter.checkEnumValue(TReligionFilterEnum::rf_karavan));
2788 setToggleButton(scenarioWnd, "neutral", religionFilter.checkEnumValue(TReligionFilterEnum::rf_neutral));
2789
2790 TGuildFilter & guildFilter = sessionBrowser._LastGuildFilter;
2791 setToggleButton(scenarioWnd, "guild_gr", (guildFilter==TGuildFilter::gf_any_player));
2792
2793 TShardFilter & shardFilter = sessionBrowser._LastShardFilter;
2794 for(uint i=0; i<Mainlands.size(); i++)
2795 setToggleButton(scenarioWnd, toString(Mainlands[i].Id), shardFilter.checkEnumValue((RSMGR::TShardFilterEnum::TValues) (1<<i)));
2796
2797 TLevelFilter & levelFilter = sessionBrowser._LastLevelFilter;
2798 setToggleButton(scenarioWnd, "20", levelFilter.checkEnumValue(TLevelFilterEnum::lf_a));
2799 setToggleButton(scenarioWnd, "50", levelFilter.checkEnumValue(TLevelFilterEnum::lf_b));
2800 setToggleButton(scenarioWnd, "100", levelFilter.checkEnumValue(TLevelFilterEnum::lf_c));
2801 setToggleButton(scenarioWnd, "150", levelFilter.checkEnumValue(TLevelFilterEnum::lf_d));
2802 setToggleButton(scenarioWnd, "200", levelFilter.checkEnumValue(TLevelFilterEnum::lf_e));
2803 setToggleButton(scenarioWnd, "250", levelFilter.checkEnumValue(TLevelFilterEnum::lf_f));
2804
2805 bool subscriptionClosed = sessionBrowser._LastSubscriptionClosed;
2806 result = scenarioWnd->findFromShortId(string("global_access_toggle_butt"));
2807 if(result)
2808 {
2809 CCtrlBaseButton * baseButton = dynamic_cast<CCtrlBaseButton*>(result);
2810 if(baseButton)
2811 baseButton->setPushed(subscriptionClosed);
2812 }
2813
2814 bool autoInvite = sessionBrowser._LastAutoInvite;
2815 result = scenarioWnd->findFromShortId(string("auto_invite_toggle_butt"));
2816 if(result)
2817 {
2818 CCtrlBaseButton * baseButton = dynamic_cast<CCtrlBaseButton*>(result);
2819 if(baseButton)
2820 baseButton->setPushed(!autoInvite);
2821 }
2822
2823 // description
2824 string description = sessionBrowser._LastDescription;
2825 if(!description.empty())
2826 {
2827 result = scenarioWnd->findFromShortId(string("edit_small_description"));
2828 if(result)
2829 {
2830 CGroupEditBox* editBox = dynamic_cast<CGroupEditBox*>(result);
2831 if(editBox)
2832 editBox->setInputString(description);
2833 }
2834 }
2835 }
2836 else
2837 {
2838 nlwarning("getSessionInfo callback return false");
2839 }
2840 }
2841 else
2842 {
2843 result = scenarioWnd->findFromShortId(string("access_players_filter"));
2844 if(result)
2845 {
2846 CInterfaceGroup* filtersGroup = dynamic_cast<CInterfaceGroup*>(result);
2847 if(filtersGroup)
2848 {
2849 std::vector<CCtrlBase*> controls;
2850 getChildrenControls(filtersGroup, controls);
2851 for(uint i=0; i<controls.size(); i++)
2852 {
2853 CCtrlBase* control = controls[i];
2854 CCtrlBaseButton * baseButton = dynamic_cast<CCtrlBaseButton*>(control);
2855 if(baseButton && (baseButton->getType()==CCtrlBaseButton::ToggleButton))
2856 baseButton->setPushed(false);
2857 }
2858 }
2859 }
2860 }
2861 }
2862 };
2863 REGISTER_ACTION_HANDLER (CAHScenarioControl, "init_scenario_control");
2864
2865
2866 // ***************************************************************************
2867 class CAHScenarioInformation : public IActionHandler
2868 {
2869 virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
2870 {
2871 nlinfo("CAHScenarioDescription called");
2872
2873 CInterfaceManager *pIM = CInterfaceManager::getInstance();
2874 CInterfaceGroup* scenarioWnd = dynamic_cast<CInterfaceGroup*>(CWidgetManager::getInstance()->getElementFromId("ui:interface:r2ed_scenario_control"));
2875 if(!scenarioWnd) return;
2876
2877 CInterfaceElement *result = scenarioWnd->findFromShortId(string("scenario_value_text"));
2878 if(result)
2879 {
2880 CViewText* viewText= dynamic_cast<CViewText*>(result);
2881
2882 if(viewText)
2883 {
2884 ScenarioFileName = getParam(Params, "ScenarioName");
2885 setScenarioInformation(scenarioWnd, ScenarioFileName);
2886
2887 string scenarioName = ScenarioFileName;
2888 string::size_type posScenarioName = 0;
2889 while(posScenarioName!=string::npos)
2890 {
2891 scenarioName = scenarioName.substr(posScenarioName==0?posScenarioName:posScenarioName+1);
2892 posScenarioName = scenarioName.find('/');
2893 }
2894 viewText->setTextLocalized(scenarioName, false);
2895 }
2896 }
2897
2898 // active description and information
2899 result = scenarioWnd->findFromShortId(string("scenario_info_prop"));
2900 if(result)
2901 result->setActive(true);
2902
2903 result = scenarioWnd->findFromShortId(string("description_gr"));
2904 if(result)
2905 result->setActive(true);
2906 }
2907 };
2908 REGISTER_ACTION_HANDLER (CAHScenarioInformation, "scenario_information");
2909
2910 // ***************************************************************************
2911 class CAHHideCharsFilters : public IActionHandler
2912 {
2913 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
2914 {
2915 nlinfo("CAHHideCharsFilters called");
2916
2917 CInterfaceManager *pIM = CInterfaceManager::getInstance();
2918 CInterfaceGroup* scenarioWnd = dynamic_cast<CInterfaceGroup*>(CWidgetManager::getInstance()->getElementFromId("ui:interface:r2ed_scenario_control"));
2919 if(!scenarioWnd) return;
2920
2921 bool lookingForPlayers = true;
2922 CInterfaceElement *result = scenarioWnd->findFromShortId(string("global_access_toggle_butt"));
2923 if(result)
2924 {
2925 CCtrlBaseButton * baseButton = dynamic_cast<CCtrlBaseButton*>(result);
2926 if(baseButton)
2927 lookingForPlayers = !baseButton->getPushed(); // warning : on / off textures are inverted !!!
2928 }
2929
2930 result = scenarioWnd->findFromShortId(string("access_body_gr"));
2931 if(result)
2932 result->setActive(lookingForPlayers);
2933
2934 result = scenarioWnd->findFromShortId(string("sep_global_access"));
2935 if(result)
2936 result->setActive(lookingForPlayers);
2937
2938 result = scenarioWnd->findFromShortId(string("auto_invite_label"));
2939 if(result)
2940 result->setActive(lookingForPlayers);
2941
2942 result = scenarioWnd->findFromShortId(string("auto_invite_toggle_butt"));
2943 if(result)
2944 result->setActive(lookingForPlayers);
2945
2946 result = scenarioWnd->findFromShortId(string("invite_team"));
2947 if(result)
2948 {
2949 bool team = (NLGUI::CDBManager::getInstance()->getDbProp("SERVER:USER:TEAM_MEMBER")->getValue8())!=0;
2950 team = (team && !(R2::getEditor().isInitialized()) && lookingForPlayers);
2951 result->setActive(team);
2952 }
2953 }
2954 };
2955 REGISTER_ACTION_HANDLER (CAHHideCharsFilters, "hide_chars_filters");
2956
2957 // ***************************************************************************
2958 class CAHLoadScenario : public IActionHandler
2959 {
2960 virtual void execute (CCtrlBase *pCaller, const string &/* Params */)
2961 {
2962 nlinfo("CAHLoadScenario called");
2963
2964 CInterfaceManager *pIM = CInterfaceManager::getInstance();
2965 CInterfaceGroup* scenarioWnd = dynamic_cast<CInterfaceGroup*>(CWidgetManager::getInstance()->getElementFromId("ui:interface:r2ed_scenario_control"));
2966 if(!scenarioWnd) return;
2967
2968 CInterfaceElement *result = NULL;
2969
2970 // load scenario
2971 if(!R2::getEditor().isInitialized())
2972 {
2973 R2::CEditor::setStartingAnimationFilename(ScenarioFileName);
2974 }
2975
2976 // description
2977 string description;
2978 result = scenarioWnd->findFromShortId(string("edit_small_description"));
2979 if(result)
2980 {
2981 CGroupEditBox* editBox = dynamic_cast<CGroupEditBox*>(result);
2982 if(editBox)
2983 description = editBox->getInputString();
2984 }
2985
2986 // races
2987 map<string, bool> races;
2988 races["fyros"] = false;
2989 races["matis"] = false;
2990 races["tryker"] = false;
2991 races["zorai"] = false;
2992 for(map<string, bool>::iterator itRace=races.begin(); itRace!=races.end(); itRace++)
2993 {
2994 result = scenarioWnd->findFromShortId(itRace->first);
2995 if(result)
2996 {
2997 CInterfaceGroup * group = dynamic_cast<CInterfaceGroup*>(result);
2998 if(group)
2999 {
3000 result = group->findFromShortId(string("toggle_butt"));
3001 if(result)
3002 {
3003 CCtrlBaseButton * baseButton = dynamic_cast<CCtrlBaseButton*>(result);
3004 if(baseButton)
3005 itRace->second = !baseButton->getPushed();
3006 }
3007 }
3008 }
3009 }
3010
3011 // religion
3012 map<string, bool> religions;
3013 religions["kami"] = false;
3014 religions["karavan"] = false;
3015 religions["neutral"] = false;
3016 for(map<string, bool>::iterator itReligion=religions.begin(); itReligion!=religions.end(); itReligion++)
3017 {
3018 result = scenarioWnd->findFromShortId(itReligion->first);
3019 if(result)
3020 {
3021 CInterfaceGroup * group = dynamic_cast<CInterfaceGroup*>(result);
3022 if(group)
3023 {
3024 result = group->findFromShortId(string("toggle_butt"));
3025 if(result)
3026 {
3027 CCtrlBaseButton * baseButton = dynamic_cast<CCtrlBaseButton*>(result);
3028 if(baseButton)
3029 itReligion->second = !baseButton->getPushed();
3030 }
3031 }
3032 }
3033 }
3034
3035 // guild
3036 bool anyPlayer = false;
3037 result = scenarioWnd->findFromShortId(string("guild_gr"));
3038 if(result)
3039 {
3040 CInterfaceGroup * group = dynamic_cast<CInterfaceGroup*>(result);
3041 if(group)
3042 {
3043 result = group->findFromShortId(string("toggle_butt"));
3044 if(result)
3045 {
3046 CCtrlBaseButton * baseButton = dynamic_cast<CCtrlBaseButton*>(result);
3047 if(baseButton)
3048 anyPlayer = !baseButton->getPushed();
3049 }
3050 }
3051 }
3052
3053 // shards
3054 std::vector<bool> shards(Mainlands.size(), false);
3055 for(uint i=0; i<Mainlands.size(); i++)
3056 {
3057 string firstKey = Mainlands[i].Description.toString();
3058
3059 result = scenarioWnd->findFromShortId(toString(Mainlands[i].Id));
3060 if(result)
3061 {
3062 CInterfaceGroup * group = dynamic_cast<CInterfaceGroup*>(result);
3063 if(group)
3064 {
3065 result = group->findFromShortId(string("toggle_butt"));
3066 if(result)
3067 {
3068 CCtrlBaseButton * baseButton = dynamic_cast<CCtrlBaseButton*>(result);
3069 if(baseButton)
3070 shards[i] = !baseButton->getPushed();
3071 }
3072 }
3073 }
3074 }
3075
3076 // levels
3077 map<string, bool> levels;
3078 levels["20"] = false;
3079 levels["50"] = false;
3080 levels["100"] = false;
3081 levels["150"] = false;
3082 levels["200"] = false;
3083 levels["250"] = false;
3084 for(map<string, bool>::iterator itLevel=levels.begin(); itLevel!=levels.end(); itLevel++)
3085 {
3086 result = scenarioWnd->findFromShortId(itLevel->first);
3087 if(result)
3088 {
3089 CInterfaceGroup * group = dynamic_cast<CInterfaceGroup*>(result);
3090 if(group)
3091 {
3092 result = group->findFromShortId(string("toggle_butt"));
3093 if(result)
3094 {
3095 CCtrlBaseButton * baseButton = dynamic_cast<CCtrlBaseButton*>(result);
3096 if(baseButton)
3097 itLevel->second = !baseButton->getPushed();
3098 }
3099 }
3100 }
3101 }
3102
3103 // global access
3104 bool globalAccess = false;
3105 result = scenarioWnd->findFromShortId(string("global_access_toggle_butt"));
3106 if(result)
3107 {
3108 CCtrlBaseButton * baseButton = dynamic_cast<CCtrlBaseButton*>(result);
3109 if(baseButton)
3110 globalAccess = !baseButton->getPushed();
3111 }
3112
3113 // auto invite
3114 bool autoInvite = false;
3115 result = scenarioWnd->findFromShortId(string("auto_invite_toggle_butt"));
3116 if(result)
3117 {
3118 CCtrlBaseButton * baseButton = dynamic_cast<CCtrlBaseButton*>(result);
3119 if(baseButton)
3120 autoInvite = !baseButton->getPushed();
3121 }
3122
3123 // invite your team
3124 bool inviteTeam = false;
3125 result = scenarioWnd->findFromShortId(string("team_toggle_butt"));
3126 if(result)
3127 {
3128 CCtrlBaseButton * baseButton = dynamic_cast<CCtrlBaseButton*>(result);
3129 if(baseButton)
3130 inviteTeam = !baseButton->getPushed();
3131 }
3132
3133 bool launchScenarioFromRingAccessPoint = false;
3134
3135 vector< pair< string, string > > values;
3136 if(R2::getEditor().isInitialized())
3137 {
3138 values = R2::getEditor().getDMC().getEditionModule().getScenarioHeader();
3139 }
3140 else
3141 {
3142 R2::CScenarioValidator sv;
3143 std::string md5, signature;
3144 sv.setScenarioToLoad(ScenarioFileName, values, md5, signature, false);
3145 launchScenarioFromRingAccessPoint = true;
3146 }
3147
3148 string rules, level, title;
3149 string initialIsland, initialEntryPoint, initialSeason;
3150 std::string lang, scenarioType;
3151 std::string otherCharAccess;
3152 std::string nevraxScenario = "0";
3153 std::string trialAllowed = "0";
3154 for(uint i=0; i<values.size(); i++)
3155 {
3156 std::pair<std::string, std::string> pair = values[i];
3157
3158 if(pair.first == "Rules") rules = pair.second;
3159 else if(pair.first == "Level") level = pair.second;
3160 else if(pair.first == "Title") title = pair.second;
3161 else if(pair.first == "InitialIsland") initialIsland = pair.second;
3162 else if(pair.first == "InitialEntryPoint") initialEntryPoint = pair.second;
3163 else if(pair.first == "InitialSeason") initialSeason = pair.second;
3164 else if(pair.first == "Language") lang = pair.second;
3165 else if(pair.first == "Type") scenarioType = pair.second;
3166 else if(pair.first == "OtherCharAccess") otherCharAccess = pair.second;
3167 else if(pair.first == "NevraxScenario") nevraxScenario = pair.second;
3168 else if(pair.first == "TrialAllowed") trialAllowed = pair.second;
3169 }
3170
3171 uint nLevel;
3172 fromString(level, nLevel);
3173 R2::TSessionLevel sessionLevel = R2::TSessionLevel::TValues(nLevel/50 + 1);
3174
3175 // ---- fix for old scenarii
3176 if (lang == "French")
3177 lang = "fr";
3178 else if (lang == "German" || lang == "Deutsch")
3179 lang = "de";
3180 else //if (lang == "English")
3181 lang = "en";
3182
3183 if (nlstricmp(scenarioType, "Roleplay") == 0 || nlstricmp(scenarioType, "Role play") == 0)
3184 scenarioType = "so_story_telling";
3185 else if (nlstricmp(scenarioType, "Combat") == 0)
3186 scenarioType = "so_hack_slash";
3187 // --------------------------
3188
3189 TRuleType ruleType(TRuleType::rt_strict);
3190 if(rules==CI18N::get("uiR2EDliberal"))
3191 ruleType = TRuleType(TRuleType::rt_liberal);
3192 else if(rules == CI18N::get("uiR2EDstrict"))
3193 ruleType = TRuleType(TRuleType::rt_strict);
3194 volatile static bool override = false;
3195 if (override)
3196 {
3197 if(rules== "Masterless")
3198 ruleType = TRuleType(TRuleType::rt_liberal);
3199 else if(rules == "Mastered")
3200 ruleType = TRuleType(TRuleType::rt_strict);
3201 }
3202
3203 TRaceFilter raceFilter;
3204 if(races["fyros"])
3205 raceFilter.setEnumValue(TRaceFilterEnum::rf_fyros);
3206 if(races["matis"])
3207 raceFilter.setEnumValue(TRaceFilterEnum::rf_matis);
3208 if(races["tryker"])
3209 raceFilter.setEnumValue(TRaceFilterEnum::rf_tryker);
3210 if(races["zorai"])
3211 raceFilter.setEnumValue(TRaceFilterEnum::rf_zorai);
3212
3213 TReligionFilter religionFilter;
3214 if(religions["kami"])
3215 religionFilter.setEnumValue(TReligionFilterEnum::rf_kami);
3216 if(religions["karavan"])
3217 religionFilter.setEnumValue(TReligionFilterEnum::rf_karavan);
3218 if(religions["neutral"])
3219 religionFilter.setEnumValue(TReligionFilterEnum::rf_neutral);
3220
3221 TGuildFilter guildFilter(anyPlayer?TGuildFilter::gf_any_player:TGuildFilter::gf_only_my_guild);
3222
3223 TShardFilter shardFilter;
3224 for (uint i = 0; i < shards.size(); ++i)
3225 {
3226 if (shards[i]) shardFilter.setEnumValue((RSMGR::TShardFilterEnum::TValues) (1<<i));
3227 }
3228
3229 TLevelFilter levelFilter;
3230 if(levels["20"])
3231 levelFilter.setEnumValue(TLevelFilterEnum::lf_a);
3232 if(levels["50"])
3233 levelFilter.setEnumValue(TLevelFilterEnum::lf_b);
3234 if(levels["100"])
3235 levelFilter.setEnumValue(TLevelFilterEnum::lf_c);
3236 if(levels["150"])
3237 levelFilter.setEnumValue(TLevelFilterEnum::lf_d);
3238 if(levels["200"])
3239 levelFilter.setEnumValue(TLevelFilterEnum::lf_e);
3240 if(levels["250"])
3241 levelFilter.setEnumValue(TLevelFilterEnum::lf_f);
3242
3243 uint32 charId = 0;
3244 if (!ClientCfg.Local)
3245 charId = (NetMngr.getLoginCookie().getUserId()<< 4) + (uint32) PlayerSelectedSlot;
3246
3247 CSessionBrowserImpl & sessionBrowser = CSessionBrowserImpl::getInstance();
3248
3249 if(R2::getEditor().getAccessMode() != R2::CEditor::AccessDM)
3250 {
3251 bool noob = NLGUI::CDBManager::getInstance()->getDbProp("SERVER:USER:IS_NEWBIE")->getValueBool();
3252 if (FreeTrial && noob && (nevraxScenario != "1" || trialAllowed != "1"))
3253 {
3254 CViewText* pVT = dynamic_cast<CViewText*>(CWidgetManager::getInstance()->getElementFromId("ui:interface:warning_free_trial:text"));
3255 if (pVT != NULL)
3256 pVT->setTextLocalized("uiRingWarningFreeTrial", true);
3257 CAHManager::getInstance()->runActionHandler("enter_modal", pCaller, "group=ui:interface:warning_free_trial");
3258
3259 return;
3260 }
3261 }
3262
3263
3264 if(R2::getEditor().getAccessMode()!=R2::CEditor::AccessDM)
3265 {
3266 if (launchScenarioFromRingAccessPoint)
3267 {
3268 // hibernate Edit Session if active
3269 sessionBrowser.hibernateEditSession(charId);
3270 if(!sessionBrowser.waitOneMessage(sessionBrowser.getMessageName("on_invokeResult")))
3271 {
3272 nlwarning("hibernateEditSession callback return false");
3273 }
3274
3275 }
3276
3277 // schedule session
3278 bool launchSuccess = true;
3279 sessionBrowser.scheduleSession(charId, TSessionType::st_anim,
3280 title, description, sessionLevel,
3281 /*TAccessType::at_public,*/ ruleType, TEstimatedDuration::et_medium, 0, TAnimMode::am_dm,
3282 raceFilter, religionFilter, guildFilter, shardFilter, levelFilter, lang, RSMGR::TSessionOrientation(scenarioType),
3283 !globalAccess, autoInvite);
3284
3285 if(sessionBrowser.waitOneMessage(sessionBrowser.getMessageName("on_scheduleSessionResult")))
3286 {
3287 if(sessionBrowser._LastScheduleSessionResult==0)
3288 {
3289 // start session
3290 sessionBrowser.startSession(sessionBrowser._LastScheduleSessionCharId,
3291 sessionBrowser._LastScheduleSessionId);
3292
3293 if(sessionBrowser.waitOneMessage(sessionBrowser.getMessageName("on_invokeResult")))
3294 {
3295
3296 if (launchScenarioFromRingAccessPoint)
3297 {
3298 if (!initialIsland.empty() && !initialEntryPoint.empty() && !initialSeason.empty())
3299 {
3300 sessionBrowser.setSessionStartParams(charId, sessionBrowser._LastScheduleSessionId, initialIsland, initialEntryPoint, initialSeason);
3301 }
3302 }
3303
3304 TSessionPartStatus sessionStatus;
3305 if(ruleType==TRuleType::rt_liberal)
3306 sessionStatus = TSessionPartStatus(TSessionPartStatus::sps_play_invited);
3307 else
3308 sessionStatus = TSessionPartStatus(TSessionPartStatus::sps_anim_invited);
3309
3310 // invite player
3311 sessionBrowser.inviteCharacter(
3312 sessionBrowser._LastScheduleSessionCharId,
3313 sessionBrowser._LastScheduleSessionId,
3314 sessionBrowser._LastScheduleSessionCharId,
3315 sessionStatus.toString());
3316
3317 if(sessionBrowser.waitOneMessage(sessionBrowser.getMessageName("on_invokeResult")))
3318 {
3319 // request session
3320 FarTP.requestFarTPToSession(sessionBrowser._LastScheduleSessionId, PlayerSelectedSlot, CFarTP::JoinSession,
3321 !R2::getEditor().isInitialized());
3322 }
3323 else
3324 {
3325 nlwarning("inviteCharacter callback return false");
3326 }
3327
3328 if (sessionBrowser._LastInvokeResult != 0)
3329 {
3330 nlwarning("inviteCharacter callback use error values %d", sessionBrowser._LastInvokeResult);
3331 }
3332
3333 if(sessionBrowser._LastInvokeResult == 14)
3334 {
3335 CViewText* pVT = dynamic_cast<CViewText*>(CWidgetManager::getInstance()->getElementFromId("ui:interface:warning_free_trial:text"));
3336 if (pVT != NULL)
3337 pVT->setTextLocalized("uiRingWarningFreeTrial", true);
3338 CAHManager::getInstance()->runActionHandler("enter_modal", pCaller, "group=ui:interface:warning_free_trial");
3339 }
3340
3341
3342 // invite team
3343 if(inviteTeam)
3344 {
3345 for (uint i = 0 ; i < 8 ; ++i)
3346 {
3347 uint32 val = NLGUI::CDBManager::getInstance()->getDbProp(NLMISC::toString("SERVER:GROUP:%d:NAME",i))->getValue32();
3348 if(val!=0)
3349 {
3350 STRING_MANAGER::CStringManagerClient *pSMC = STRING_MANAGER::CStringManagerClient::instance();
3351 string res;
3352 if (pSMC->getString(val,res))
3353 {
3354 string charName = CEntityCL::removeTitleAndShardFromName(res);
3355 sessionBrowser.inviteCharacterByName(sessionBrowser._LastScheduleSessionCharId, charName);
3356
3357 if(!sessionBrowser.waitOneMessage(sessionBrowser.getMessageName("on_invokeResult")))
3358 {
3359 nlwarning("inviteCharacterByName callback return false");
3360 }
3361
3362 if(sessionBrowser._LastInvokeResult == 14)
3363 {
3364 CViewText* pVT = dynamic_cast<CViewText*>(CWidgetManager::getInstance()->getElementFromId("ui:interface:warning_free_trial:text"));
3365 if (pVT != NULL)
3366 pVT->setTextLocalized("uiRingWarningInviteFreeTrial", true);
3367 CAHManager::getInstance()->runActionHandler("enter_modal", pCaller, "group=ui:interface:warning_free_trial");
3368 }
3369 }
3370 }
3371 }
3372 }
3373 }
3374 else
3375 {
3376 nlwarning("startSession callback return false");
3377 launchSuccess = false;
3378 }
3379 }
3380 else if(sessionBrowser._LastScheduleSessionResult==10)
3381 {
3382 pIM->messageBoxWithHelp(CI18N::get("uiRingWarningBanishedPlayer"));
3383 }
3384 else
3385 {
3386 launchSuccess=false;
3387 }
3388 }
3389 else
3390 {
3391 nlwarning("scheduleSession callback return false");
3392 launchSuccess = false;
3393 }
3394
3395 if(!launchSuccess)
3396 {
3397 pIM->messageBoxWithHelp(CI18N::get("uiRingLaunchScenarioError"));
3398 }
3399 else
3400 {
3401 scenarioWnd->setActive(false);
3402 }
3403 }
3404 else
3405 {
3406 // update session
3407 sessionBrowser.updateSessionInfo(charId, sessionBrowser._LastScheduleSessionId, title, 0, description, sessionLevel,
3408 /*TAccessType::at_public, */TEstimatedDuration::et_medium, 0, raceFilter, religionFilter,
3409 guildFilter, shardFilter, levelFilter, !globalAccess, autoInvite, lang, RSMGR::TSessionOrientation(scenarioType));
3410
3411 if(!sessionBrowser.waitOneMessage(sessionBrowser.getMessageName("on_invokeResult")))
3412 {
3413 nlwarning("updateSessionInfo callback return false");
3414 pIM->messageBoxWithHelp(CI18N::get("uiRingUpdateScenarioFiltersError"));
3415 }
3416 else
3417 {
3418 scenarioWnd->setActive(false);
3419 }
3420 }
3421 }
3422 };
3423 REGISTER_ACTION_HANDLER (CAHLoadScenario, "load_scenario");
3424
3425
3426 // ***************************************************************************
3427 class CAHOpenRingSessions : public IActionHandler
3428 {
3429 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
3430 {
3431 if(!R2::getEditor().isInitialized())
3432 {
3433 CInterfaceManager *pIM = CInterfaceManager::getInstance();
3434 CInterfaceGroup* ringSessionsWnd = dynamic_cast<CInterfaceGroup*>(CWidgetManager::getInstance()->getElementFromId("ui:interface:ring_sessions"));
3435 if(!ringSessionsWnd) return;
3436 ringSessionsWnd->setActive(true);
3437 }
3438 }
3439 };
3440 REGISTER_ACTION_HANDLER (CAHOpenRingSessions, "open_ring_sessions");
3441
3442 // ***************************************************************************
3443 class CAHInitImportCharacter : public IActionHandler
3444 {
3445 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
3446 {
3447 CInterfaceGroup *list = dynamic_cast<CInterfaceGroup*>(CWidgetManager::getInstance()->getElementFromId(GROUP_LIST_CHARACTER));
3448 if (!list)
3449 {
3450 nlwarning("element " GROUP_LIST_CHARACTER " not found probably bad outgame.xml");
3451 return;
3452 }
3453
3454 // retrieve saved files
3455 std::vector<string> savedCharacters;
3456 CPath::getPathContent("save/", false, false, true, savedCharacters);
3457
3458 CInterfaceGroup *newLine;
3459 CInterfaceGroup *prevLine = NULL;
3460
3461 for (uint i = 0; i < savedCharacters.size(); ++i)
3462 {
3463 // search saved characters only
3464 if (testWildCard(CFile::getFilename(savedCharacters[i]), "character_*.save"))
3465 {
3466 const std::string id = CFile::getFilenameWithoutExtension(savedCharacters[i]).substr(strlen("character_"));
3467 if (id.empty())
3468 continue;
3469
3470 std::vector<pair<string, string>> params;
3471 params.clear();
3472 params.push_back(std::pair<string, string>("id", id));
3473 // adjust ref
3474 if (list->getNumGroup() > 0)
3475 params.push_back(std::pair<string, string>("posref", "BL TL"));
3476
3477 newLine = CWidgetManager::getInstance()->getParser()->createGroupInstance("t_import", GROUP_LIST_CHARACTER, params);
3478 if (newLine)
3479 {
3480 CViewText *text = dynamic_cast<CViewText*>(newLine->getView("name"));
3481 if (text)
3482 text->setText(string(savedCharacters[i]));
3483
3484 // first button is pushed
3485 CCtrlButton *button = dynamic_cast<CCtrlButton*>(newLine->getCtrl("but"));
3486 if (button && list->getNumGroup() == 0)
3487 button->setPushed(true);
3488
3489 // add to the list now
3490 newLine->setParent(list);
3491 newLine->setParentSize(list);
3492 newLine->setParentPos(prevLine);
3493
3494 list->addGroup(newLine);
3495
3496 prevLine = newLine;
3497 }
3498 }
3499 }
3500 // none case
3501 if (list->getNumGroup() == 0)
3502 CLuaManager::getInstance().executeLuaScript("outgame:procCharselNotifaction(3)");
3503
3504 list->invalidateCoords();
3505 }
3506 };
3507 REGISTER_ACTION_HANDLER( CAHInitImportCharacter, "import_char_init" );
3508
3509 // ***************************************************************************
3510 class CAHResetImportCharacter : public IActionHandler
3511 {
3512 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
3513 {
3514 CInterfaceGroup *list = dynamic_cast<CInterfaceGroup*>(CWidgetManager::getInstance()->getElementFromId(GROUP_LIST_CHARACTER));
3515 if (list)
3516 list->clearGroups();
3517
3518 if (!ImportCharacter.empty())
3519 ImportCharacter = "";
3520 }
3521 };
3522 REGISTER_ACTION_HANDLER( CAHResetImportCharacter, "import_char_reset" );
3523
3524 // ***************************************************************************
3525 class CAHSelectImportCharacter : public IActionHandler
3526 {
3527 virtual void execute (CCtrlBase *pCaller, const std::string &Params)
3528 {
3529 struct CUnpush : public CInterfaceElementVisitor
3530 {
3531 CCtrlBase *Ref;
3532 virtual void visitCtrl(CCtrlBase *ctrl)
3533 {
3534 if (ctrl == Ref) return;
3535 CCtrlBaseButton *but = dynamic_cast<CCtrlBaseButton*>(ctrl);
3536 if (but)
3537 {
3538 but->setPushed(false);
3539 }
3540 }
3541 };
3542 CInterfaceGroup *list = dynamic_cast<CInterfaceGroup*>(CWidgetManager::getInstance()->getElementFromId(GROUP_LIST_CHARACTER));
3543 if (!list)
3544 return;
3545
3546 // unselect
3547 if (Params.empty())
3548 {
3549 CUnpush unpusher;
3550 unpusher.Ref = pCaller;
3551 list->visit(&unpusher);
3552 }
3553
3554 // now select
3555 std::string name;
3556 if (Params.empty())
3557 {
3558 CCtrlButton *pCB = dynamic_cast<CCtrlButton*>(pCaller);
3559 if (!pCB)
3560 return;
3561
3562 std::string id = pCB->getId();
3563 id = id.substr(0, id.rfind(':'));
3564
3565 if (!fromString(id.substr(id.rfind(':')+1, id.size()), name))
3566 return;
3567
3568 pCB->setPushed(true);
3569 }
3570 else
3571 if (!fromString(Params, name))
3572 return;
3573
3574 ImportCharacter = "";
3575 // check filename and store
3576 if (CFile::fileExists(toString("save/character_%s.save", name.c_str())))
3577 ImportCharacter = name;
3578 }
3579 };
3580 REGISTER_ACTION_HANDLER( CAHSelectImportCharacter, "import_char_select" );
3581
3582 // ***************************************************************************
3583 class CAHImportCharacter : public IActionHandler
3584 {
3585 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
3586 {
3587 if (ImportCharacter.empty())
3588 return;
3589
3590 if (!CFile::fileExists(toString("save/character_%s.save", ImportCharacter.c_str())))
3591 return;
3592
3593 bool success = false;
3594
3595 CIFile fd;
3596 CCharacterSummary CS;
3597 // use temporary file until close()
3598 if (fd.open(toString("save/character_%s.save", ImportCharacter.c_str())))
3599 {
3600 try
3601 {
3602 CS.serial(fd);
3603 SCharacter3DSetup::setupDBFromCharacterSummary("UI:TEMP:CHAR3D", CS);
3604
3605 // validate import
3606 CDBManager::getInstance()->getDbProp("UI:TEMP:IMPORT")->setValue32(1);
3607 success = true;
3608 }
3609 catch (const EStream &e)
3610 {
3611 nlwarning(e.what());
3612 }
3613 fd.close();
3614 }
3615 else
3616 nlwarning("Failed to open file: save/character_%s.save", ImportCharacter.c_str());
3617
3618 // user notification
3619 if (!success)
3620 CLuaManager::getInstance().executeLuaScript("outgame:procCharselNotifaction(2)");
3621 else
3622 CAHManager::getInstance()->runActionHandler("proc", NULL, "proc_charsel_create_new");
3623 }
3624 };
3625 REGISTER_ACTION_HANDLER( CAHImportCharacter, "import_char" );
3626
3627 // ***************************************************************************
3628 class CAHExportCharacter : public IActionHandler
3629 {
3630 virtual void execute (CCtrlBase * /* pCaller */, const std::string &Params)
3631 {
3632 if (Params.empty())
3633 return;
3634
3635 sint32 slot = -1;
3636 if (!fromString(getParam(Params, "slot"), slot))
3637 return;
3638
3639 if (slot >= CharacterSummaries.size() || slot < 0)
3640 return;
3641
3642 // retrieve infos
3643 CCharacterSummary &CS = CharacterSummaries[slot];
3644 if (CS.Name.empty())
3645 return;
3646
3647 // extract name
3648 const std::string name = buildPlayerNameForSaveFile(CS.Name.toUtf8());
3649
3650 COFile fd;
3651 bool success = false;
3652 // use temporary file until close()
3653 if (fd.open(toString("save/character_%s.save", name.c_str()), false, false, true))
3654 {
3655 try
3656 {
3657 fd.serial(CS);
3658 fd.flush();
3659 // validate
3660 success = true;
3661 }
3662 catch (const EStream &e)
3663 {
3664 nlwarning(e.what());
3665 }
3666 fd.close();
3667 }
3668 else
3669 nlwarning("Failed to open file: save/character_%s.save", name.c_str());
3670
3671 const uint8 val = (success == true) ? 0 : 1;
3672 // user notification
3673 CLuaManager::getInstance().executeLuaScript(toString("outgame:procCharselNotifaction(%i)", val));
3674 }
3675 };
3676 REGISTER_ACTION_HANDLER( CAHExportCharacter, "export_char" );