?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch '138-toggle-free-look-with-hotkey' into main/gingo-test
[ryzomcore.git] / ryzom / client / src / interface_v3 / action_handler_game.cpp
blob790c8b13d10b84e56716ac1e776176bc75da8bb8
1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
2 // Copyright (C) 2010-2021 Winch Gate Property Limited
3 //
4 // This source file has been modified by the following contributors:
5 // Copyright (C) 2013 Laszlo KIS-ADAM (dfighter) <dfighter1985@gmail.com>
6 // Copyright (C) 2013-2020 Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
7 //
8 // This program is free software: you can redistribute it and/or modify
9 // it under the terms of the GNU Affero General Public License as
10 // published by the Free Software Foundation, either version 3 of the
11 // License, or (at your option) any later version.
12 //
13 // This program is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 // GNU Affero General Public License for more details.
17 //
18 // You should have received a copy of the GNU Affero General Public License
19 // along with this program. If not, see <http://www.gnu.org/licenses/>.
20
21
22
23
24 #include "stdpch.h"
25
26 #include <sstream>
27 #include <locale>
28
29 // Interface includes
30 #include "interface_manager.h"
31 #include "nel/gui/action_handler.h"
32 #include "action_handler_base.h"
33 #include "action_handler_misc.h"
34 #include "bot_chat_manager.h"
35 #include "bot_chat_page_all.h"
36 #include "bot_chat_page_news.h"
37 #include "bot_chat_page_create_guild.h"
38 #include "bot_chat_page_mission.h"
39 #include "bot_chat_page_mission_end.h"
40 #include "bot_chat_page_trade.h"
41 #include "bot_chat_page_player_gift.h"
42 #include "bot_chat_page_dynamic_mission.h"
43 #include "bot_chat_page_ring_sessions.h"
44 #include "dbctrl_sheet.h"
45 #include "nel/gui/ctrl_sheet_selection.h"
46 #include "nel/gui/interface_expr.h"
47 #include "nel/gui/group_menu.h"
48 #include "nel/gui/group_container.h"
49 #include "nel/gui/group_editbox.h"
50 #include "inventory_manager.h"
51 #include "guild_manager.h"
52 #include "../net_manager.h"
53 #include "interface_ddx.h"
54 #include "nel/gui/group_tree.h"
55 #include "group_map.h"
56 #include "nel/gui/view_bitmap.h"
57 #include "action_handler_tools.h"
58 #include "../connection.h"
59 #include "../client_chat_manager.h"
60 #include "group_compas.h"
61
62 // Game specific includes
63 #include "../motion/user_controls.h"
64 #include "../entities.h"
65 #include "../misc.h"
66 #include "../sheet_manager.h"
67 #include "../actions_client.h"
68 #include "people_interraction.h"
69 #include "../game_context_menu.h"
70 #include "../sound_manager.h"
71 #include "../far_tp.h"
72 #include "nel/gui/interface_link.h"
73 #include "../npc_icon.h"
74 #include "user_agent.h"
75
76 // Game Share
77 #include "game_share/character_summary.h"
78 #include "game_share/brick_types.h"
79 #include "game_share/seeds.h"
80 #include "game_share/entity_types.h"
81 #include "game_share/inventories.h"
82 //#include "game_share/sheath.h"
83 //#include "game_share/jobs.h"
84 #include "game_share/animals_orders.h"
85 #include "game_share/animal_status.h"
86 #include "game_share/animal_type.h"
87 #include "game_share/interface_flags.h"
88 #include "game_share/slot_equipment.h"
89 #include "game_share/bot_chat_types.h"
90 #include "game_share/constants.h"
91 #include "game_share/scores.h"
92
93 // Game Config
94 #include "nel/gui/dbgroup_combo_box.h"
95 #include "nel/gui/ctrl_button.h"
96 #include "../global.h"
97
98 using namespace std;
99 using namespace NL3D;
100 using namespace NLMISC;
101 using namespace BRICK_TYPE;
102
103 extern NL3D::UDriver *Driver;
104 extern NLMISC::CLog g_log;
105 extern bool ShowInterface;
106 extern bool ShowHelp;
107 extern uint8 PlayerSelectedSlot;
108 extern bool IsInRingSession;
109
110 // Context help
111 extern void contextHelp (const std::string &help);
112
113 extern CClientChatManager ChatMngr;
114
115 void beastOrder (const std::string &orderStr, const std::string &beastIndexStr, bool confirmFree = true);
116
117
118 string convertLanguageIntToLanguageCode(sint val)
119 {
120 switch(val)
121 {
122 default:
123 case 0: return "en"; break;
124 case 1: return "fr"; break;
125 case 2: return "de"; break;
126 case 3: return "ru"; break;
127 case 4: return "es"; break;
128 }
129 }
130
131 /**********************************************************************************************************
132 * *
133 * GAME CONTEXT MENU handlers *
134 * *
135 ***********************************************************************************************************/
136
137
138 // Does the player know this skill?
139 static bool playerKnowSkill( SKILLS::ESkills e)
140 {
141 CInterfaceManager *pIM = CInterfaceManager::getInstance();
142 string sPath = "SERVER:CHARACTER_INFO:SKILLS:" + toStringEnum( e ) + ":SKILL";
143 CCDBNodeLeaf *pNL = NLGUI::CDBManager::getInstance()->getDbProp(sPath,false);
144 if ((pNL != NULL) && (pNL->getValue64() > 0))
145 return true;
146 else
147 return false;
148 }
149
150
151 // ***************************************************************************
152 // GCM Activation : called when activate the game context menu
153 // ***************************************************************************
154
155 class CHandlerActiveGameContextMenu : public IActionHandler
156 {
157 public:
158 void execute (CCtrlBase *pCaller, const std::string &/* sParams */)
159 {
160 // Invalidate all lines
161 CGroupMenu *pGM = dynamic_cast<CGroupMenu*>(pCaller);
162 if (pGM == NULL) return;
163
164 // Id names of the lines in the game_context_menu.xml ...
165 static const char *sIdNames[] = { "talk", "use", "lift", "look", "attack", "invit", "exchange",
166 "mount", "train" };
167 const uint32 numOptions = sizeof(sIdNames) / sizeof(sIdNames[0]);
168
169 uint32 i;
170 CViewTextMenu *pVTM;
171 const string sMenuPath = "ui:interface:game_context_menu";
172
173 for (i = 0; i < numOptions; ++i)
174 {
175 pVTM = dynamic_cast<CViewTextMenu*>(pGM->getElement(sMenuPath+":"+sIdNames[i]));
176 if (pVTM != NULL) pVTM->setGrayed(true);
177 }
178 }
179 };
180 REGISTER_ACTION_HANDLER( CHandlerActiveGameContextMenu, "active_game_context_menu");
181
182 // ***************************************************************************
183 // GCM Talk
184 // ***************************************************************************
185
186 class CHandlerContextTalk : public IActionHandler
187 {
188 public:
189 void execute (CCtrlBase *pCaller, const std::string &/* sParams */)
190 {
191 CInterfaceManager *im = CInterfaceManager::getInstance();
192 CEntityCL *selection = EntitiesMngr.entity(UserEntity->selection());
193 if (selection && selection->Type == CEntityCL::Player)
194 {
195 string name = CEntityCL::removeTitleAndShardFromName(selection->getEntityName());
196 if (name.empty()) return;
197 CAHManager::getInstance()->runActionHandler("enter_tell", pCaller, "player=" + name);
198 }
199 }
200 protected:
201 };
202 REGISTER_ACTION_HANDLER( CHandlerContextTalk, "context_talk");
203
204
205
206
207 // ***************************************************************************
208 // sendBotChatStart
209 // helper increment session id and send session id to the server with specified message
210 // ***************************************************************************
211 static void sendBotChatStart(const string &msgName)
212 {
213 CBotChatManager::getInstance()->incrementSessionID();
214 CBitMemStream out;
215 string msg = "BOTCHAT:" + msgName;;
216 if(GenericMsgHeaderMngr.pushNameToStream(msg, out))
217 {
218 uint16 session = CBotChatManager::getInstance()->getSessionID();
219 out.serial(session);
220 NetMngr.push(out);
221 }
222 else
223 {
224 nlwarning("msg %s does not exist.", msg.c_str());
225 }
226 }
227
228
229 // ***************************************************************************
230 // GCM Ring Sessions
231 // ***************************************************************************
232 class CHandlerContextRingSessions : public IActionHandler
233 {
234 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
235 {
236 // do not send start message to server here (not really a bot chage page, but should dissapear
237 // when player go away)
238
239 CInterfaceManager *pIM = CInterfaceManager::getInstance();
240 CInterfaceElement *pIE = CWidgetManager::getInstance()->getElementFromId("ui:interface:ring_sessions");
241
242 // check if selection is a Ring terminal
243 CEntityCL * selection = EntitiesMngr.entity(UserEntity->selection());
244 if (selection && selection->sheetId()==NLMISC::CSheetId("object_karavan_device_neutrl_sel.creature"))
245 {
246 CVectorD vect1 = selection->pos();
247 CVectorD vect2 = UserEntity->pos();
248
249 double distanceSquare = pow(vect1.x-vect2.x,2) + pow(vect1.y-vect2.y,2);
250
251 if(distanceSquare > MaxTalkingDistSquare)
252 {
253 UserEntity->moveTo(UserEntity->selection(), 3.0, CUserEntity::WebPage);
254 if (pIE->getActive())
255 {
256 CBotChatManager::getInstance()->setCurrPage(NULL);
257 }
258 }
259 else
260 {
261 if (!pIE->getActive())
262 {
263 CBotChatManager::getInstance()->setCurrPage(BotChatPageAll->RingSessions);
264 }
265 }
266 }
267 else
268 {
269 if (pIE != NULL) pIE->setActive(false);
270 }
271 }
272 };
273 REGISTER_ACTION_HANDLER( CHandlerContextRingSessions, "context_ring_sessions");
274
275
276 // ***************************************************************************
277 // GCM Trade Item (with bot)
278 // ***************************************************************************
279 class CHandlerContextTradeItem : public IActionHandler
280 {
281 public:
282 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
283 {
284 sendBotChatStart("START_TRADE_ITEM");
285 BotChatPageAll->Trade->setBuyOnly(false);
286 BotChatPageAll->Trade->setBuyMean(CBotChatPageTrade::Money);
287 BotChatPageAll->Trade->setTitle(NLMISC::CI18N::get("uiBotChatTrade"));
288 CBotChatManager::getInstance()->setCurrPage(BotChatPageAll->Trade);
289
290 // Context help
291 contextHelp ("inventory");
292 }
293 };
294 REGISTER_ACTION_HANDLER( CHandlerContextTradeItem, "context_trade_item");
295
296 // ***************************************************************************
297 // GCM Trade Teleport (with bot)
298 // ***************************************************************************
299 class CHandlerContextTradeTeleport : public IActionHandler
300 {
301 public:
302 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
303 {
304 sendBotChatStart("START_TRADE_TELEPORT");
305 BotChatPageAll->Trade->setBuyOnly(true);
306 BotChatPageAll->Trade->setBuyMean(CBotChatPageTrade::Money);
307 BotChatPageAll->Trade->setTitle(NLMISC::CI18N::get("uiBotChatTeleport"));
308 CBotChatManager::getInstance()->setCurrPage(BotChatPageAll->Trade);
309 // Context help
310 contextHelp ("inventory");
311 }
312 };
313 REGISTER_ACTION_HANDLER( CHandlerContextTradeTeleport, "context_trade_teleport");
314
315 // ***************************************************************************
316 // GCM Trade Faction items/bricks/named items/bonuses (with bot)
317 // ***************************************************************************
318 class CHandlerContextTradeFaction : public IActionHandler
319 {
320 public:
321 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
322 {
323 sendBotChatStart("START_TRADE_FACTION");
324 BotChatPageAll->Trade->setBuyOnly(true);
325 BotChatPageAll->Trade->setBuyMean(CBotChatPageTrade::MoneyFactionPoints);
326 BotChatPageAll->Trade->setTitle(NLMISC::CI18N::get("uiBotChatFaction"));
327 CBotChatManager::getInstance()->setCurrPage(BotChatPageAll->Trade);
328 // Context help
329 contextHelp ("inventory");
330 }
331 };
332 REGISTER_ACTION_HANDLER( CHandlerContextTradeFaction, "context_trade_faction");
333
334 // ***************************************************************************
335 // GCM Trade Cosmetic (with bot)
336 // ***************************************************************************
337 class CHandlerContextTradeCosmetic : public IActionHandler
338 {
339 public:
340 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
341 {
342 sendBotChatStart("START_TRADE_ITEM");
343 BotChatPageAll->Trade->setBuyOnly(true);
344 BotChatPageAll->Trade->setBuyMean(CBotChatPageTrade::Money);
345 BotChatPageAll->Trade->setTitle(NLMISC::CI18N::get("uiBotChatCosmetic"));
346 CBotChatManager::getInstance()->setCurrPage(BotChatPageAll->Trade);
347 // Context help
348 contextHelp ("inventory");
349 }
350 };
351 REGISTER_ACTION_HANDLER( CHandlerContextTradeCosmetic, "context_trade_cosmetic");
352
353 // ***************************************************************************
354 // GCM Trade Guild Options (with bot) (le concierge)
355 // ***************************************************************************
356 class CHandlerContextTradeGuildOptions : public IActionHandler
357 {
358 public:
359 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
360 {
361 sendBotChatStart("START_TRADE_GUILD_OPTIONS");
362 BotChatPageAll->Trade->setBuyOnly(true);
363 BotChatPageAll->Trade->setBuyMean(CBotChatPageTrade::MoneyGuildXP);
364 BotChatPageAll->Trade->setTitle(NLMISC::CI18N::get("uiBotChatGuildOptions"));
365 CBotChatManager::getInstance()->setCurrPage(BotChatPageAll->Trade);
366 // Context help
367 contextHelp ("inventory");
368 }
369 };
370 REGISTER_ACTION_HANDLER( CHandlerContextTradeGuildOptions, "context_trade_guild_options");
371
372 // ***************************************************************************
373 // GCM Trade Outpost Building (with bot) (the building itself)
374 // ***************************************************************************
375 class CHandlerContextTradeOutpostBuilding : public IActionHandler
376 {
377 public:
378 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
379 {
380 sendBotChatStart("START_TRADE_GUILD_OPTIONS");
381 BotChatPageAll->Trade->setBuyOnly(true);
382 BotChatPageAll->Trade->setBuyMean(CBotChatPageTrade::GuildMoney);
383 BotChatPageAll->Trade->setTitle(NLMISC::CI18N::get("uiBotChatGuildOptions"));
384 CBotChatManager::getInstance()->setCurrPage(BotChatPageAll->Trade);
385 // Context help
386 contextHelp ("inventory");
387 }
388 };
389 REGISTER_ACTION_HANDLER( CHandlerContextTradeOutpostBuilding, "context_trade_outpost_building");
390
391 // ***************************************************************************
392 // GCM Trade phrase from the guild role master
393 // ***************************************************************************
394 class CHandlerContextTradeGuildRoleMaster : public IActionHandler
395 {
396 public:
397 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
398 {
399 sendBotChatStart("START_GUILD_RESEARCH");
400 BotChatPageAll->Trade->setBuyOnly(true);
401 BotChatPageAll->Trade->setBuyMean(CBotChatPageTrade::GuildXP);
402 BotChatPageAll->Trade->setTitle(NLMISC::CI18N::get("uiBotChatGuildRoleMaster"));
403 CBotChatManager::getInstance()->setCurrPage(BotChatPageAll->Trade);
404 // Context help
405 contextHelp ("inventory");
406 }
407 };
408 REGISTER_ACTION_HANDLER( CHandlerContextTradeGuildRoleMaster, "context_trade_guild_role_master");
409
410 // ***************************************************************************
411 // GCM Trade Skill (with bot)
412 // ***************************************************************************
413 class CHandlerContextTradeSkill : public IActionHandler
414 {
415 public:
416 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
417 {
418 sendBotChatStart("START_TRADE_SKILL");
419 BotChatPageAll->Trade->setBuyOnly(true);
420 BotChatPageAll->Trade->setBuyMean(CBotChatPageTrade::SkillPoints);
421 BotChatPageAll->Trade->setTitle(NLMISC::CI18N::get("uiLearn"));
422 CBotChatManager::getInstance()->setCurrPage(BotChatPageAll->Trade);
423 }
424 };
425 REGISTER_ACTION_HANDLER(CHandlerContextTradeSkill, "context_trade_skill");
426
427 // ***************************************************************************
428 // GCM Trade Pacts (with bot)
429 // ***************************************************************************
430 class CHandlerContextTradePact : public IActionHandler
431 {
432 public:
433 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
434 {
435 sendBotChatStart("START_TRADE_PACT");
436 BotChatPageAll->Trade->setBuyOnly(true);
437 BotChatPageAll->Trade->setBuyMean(CBotChatPageTrade::SkillPoints);
438 BotChatPageAll->Trade->setTitle(NLMISC::CI18N::get("uiLearn"));
439 CBotChatManager::getInstance()->setCurrPage(BotChatPageAll->Trade);
440 }
441 };
442 REGISTER_ACTION_HANDLER(CHandlerContextTradePact, "context_trade_pact");
443
444 // ***************************************************************************
445 // GCM Trade Phrases (with bot)
446 // ***************************************************************************
447 class CHandlerContextTradePhrase : public IActionHandler
448 {
449 public:
450 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
451 {
452 sendBotChatStart("START_TRADE_ACTION");
453 BotChatPageAll->Trade->setBuyOnly(true);
454 BotChatPageAll->Trade->setBuyMean(CBotChatPageTrade::SkillPoints);
455 BotChatPageAll->Trade->setTitle(NLMISC::CI18N::get("uiLearn"));
456 CBotChatManager::getInstance()->setCurrPage(BotChatPageAll->Trade);
457 }
458 };
459 REGISTER_ACTION_HANDLER(CHandlerContextTradePhrase, "context_trade_phrase");
460
461 // ***************************************************************************
462 // GCM Choose mission
463 // ***************************************************************************
464 class CHandlerContextChooseMission : public IActionHandler
465 {
466 public:
467 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
468 {
469 sendBotChatStart("START_CHOOSE_MISSION");
470 BotChatPageAll->ChooseMission->setMissionClientType(MISSION_DESC::Mission);
471 CBotChatManager::getInstance()->setCurrPage(BotChatPageAll->ChooseMission);
472 }
473 };
474 REGISTER_ACTION_HANDLER(CHandlerContextChooseMission, "context_choose_mission");
475
476 // ***************************************************************************
477 // GCM Create guild
478 // ***************************************************************************
479 class CHandlerContextCreateGuild : public IActionHandler
480 {
481 public:
482 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
483 {
484 CBotChatManager::getInstance()->incrementSessionID();
485
486 sendMsgToServer("BOTCHAT:START_CREATE_GUILD");
487
488 CBotChatManager::getInstance()->setCurrPage(BotChatPageAll->CreateGuild);
489
490 // Context help
491 contextHelp ("guild");
492 }
493 };
494 REGISTER_ACTION_HANDLER(CHandlerContextCreateGuild, "context_create_guild");
495
496
497 // ***************************************************************************
498 // GCM Mission option
499 // ***************************************************************************
500 class CHandlerContextOpenMissionOption : public IActionHandler
501 {
502 public:
503 void execute (CCtrlBase * /* pCaller */, const std::string &sParams)
504 {
505 std::string id = getParam(sParams, "id");
506 sint intId;
507 if (!fromString(id, intId)) return;
508 //nlinfo("intId = %d", intId);
509 CBotChatManager::getInstance()->incrementSessionID();
510 //
511 CInterfaceManager *im = CInterfaceManager::getInstance();
512 // get flags
513 std::string playerGiftNeededDbPath = toString("LOCAL:TARGET:CONTEXT_MENU:MISSIONS_OPTIONS:%d:PLAYER_GIFT_NEEDED", intId);
514 CCDBNodeLeaf *playerGiftNeeded = NLGUI::CDBManager::getInstance()->getDbProp(playerGiftNeededDbPath, false);
515 if (!playerGiftNeeded) return;
516 //
517 //CBotChatManager::getInstance()->setChosenMissionFlags((uint) missionFlags->getValue8());
518 // a gift from player is required
519 sendMsgToServer("BOTCHAT:CONTINUE_MISSION", (uint8)intId);
520
521 if (playerGiftNeeded->getValue8())
522 {
523 CBotChatManager::getInstance()->setCurrPage(BotChatPageAll->PlayerGift);
524 }
525 }
526 };
527 REGISTER_ACTION_HANDLER(CHandlerContextOpenMissionOption, "open_mission_option");
528
529
530 class CHandlerContextMissionOption : public IActionHandler
531 {
532 public:
533 void execute (CCtrlBase * /* pCaller */, const std::string &sParams)
534 {
535 std::string id = getParam(sParams, "id");
536 sint intId;
537 if (!fromString(id, intId)) return;
538 UserEntity->moveToMission(UserEntity->targetSlot(), 3.0, intId);
539 }
540 };
541 REGISTER_ACTION_HANDLER(CHandlerContextMissionOption, "mission_option");
542
543
544
545
546 // ***************************************************************************
547 // GCM Missions
548 // ***************************************************************************
549 /*
550 class CHandlerContextMissions : public IActionHandler
551 {
552 public:
553 void execute (CCtrlBase *pCaller, const std::string &sParams)
554 {
555 CInterfaceManager *im = CInterfaceManager::getInstance();
556 // if there is only a single page available for missions, go to that page directly
557 CCDBNodeLeaf *progs = NLGUI::CDBManager::getInstance()->getDbProp("SERVER:TARGET:PROGRAMMES", false);
558 if (!progs)
559 {
560 nlwarning("<CHandlerContextMissions::execute> can't retrieve programs.");
561 return;
562 }
563 bool missionsToDo = (progs->getValue32() & (1 << BOTCHATTYPE::AvailableMissionFamily)) != 0;
564 bool missionsToContinue = (progs->getValue32() & (1 << BOTCHATTYPE::CompletedMissionFamily)) != 0;
565 bool missionsTofinish = (progs->getValue32() & (1 << BOTCHATTYPE::ContinuedMissionFamily)) != 0;
566 if (missionsToDo && !missionsToContinue && !missionsTofinish)
567 {
568 startBotChatAtPage(BOTCHATTYPE::AvailableMissions);
569 }
570 else if (!missionsToDo && missionsToContinue && !missionsTofinish)
571 {
572 startBotChatAtPage(BOTCHATTYPE::MissionProgress);
573 }
574 else if (!missionsToDo && !missionsToContinue && missionsTofinish)
575 {
576 startBotChatAtPage(BOTCHATTYPE::CompletedMissions);
577 }
578 else
579 {
580 startBotChatAtPage(BOTCHATTYPE::MissionStartPage);
581 }
582 }
583 };
584 REGISTER_ACTION_HANDLER(CHandlerContextMissions, "context_missions");
585 */
586
587 // ***************************************************************************
588 // GCM Available missions
589 // ***************************************************************************
590 /*
591 class CHandlerContextAvailableMissions : public IActionHandler
592 {
593 public:
594 void execute (CCtrlBase *pCaller, const std::string &sParams)
595 {
596 startBotChatAtPage(BOTCHATTYPE::AvailableMissions); // missions list page. If only one option, go to this page ?
597 }
598 };
599 REGISTER_ACTION_HANDLER(CHandlerContextAvailableMissions, "context_available_missions");
600
601 // ***************************************************************************
602 // GCM Constinue missions
603 // ***************************************************************************
604 class CHandlerContextContinueMissions : public IActionHandler
605 {
606 public:
607 void execute (CCtrlBase *pCaller, const std::string &sParams)
608 {
609 startBotChatAtPage(BOTCHATTYPE::MissionProgress); // missions list page. If only one option, go to this page ?
610 }
611 };
612 REGISTER_ACTION_HANDLER(CHandlerContextContinueMissions, "context_continue_missions");
613
614 // ***************************************************************************
615 // GCM Finish missions
616 // ***************************************************************************
617 class CHandlerContextFinishMissions : public IActionHandler
618 {
619 public:
620 void execute (CCtrlBase *pCaller, const std::string &sParams)
621 {
622 startBotChatAtPage(BOTCHATTYPE::CompletedMissions); // missions list page. If only one option, go to this page ?
623 }
624 };
625 REGISTER_ACTION_HANDLER(CHandlerContextFinishMissions, "context_finish_missions");
626 */
627
628
629 // ***************************************************************************
630 // GCM Attack
631 // ***************************************************************************
632
633 class CHandlerContextAttack : public IActionHandler
634 {
635 public:
636 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
637 {
638
639 if( !UserEntity->canEngageCombat() )
640 return;
641
642 // Move to the current selection and attack.
643 UserEntity->moveToAttack();
644 }
645 protected:
646 };
647 REGISTER_ACTION_HANDLER( CHandlerContextAttack, "context_attack");
648
649 // ***************************************************************************
650 // GCM Duel
651 // ***************************************************************************
652
653 class CHandlerContextDuel : public IActionHandler
654 {
655 public:
656 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
657 {
658 sendMsgToServer("DUEL:ASK");
659 }
660 };
661 REGISTER_ACTION_HANDLER( CHandlerContextDuel, "context_duel");
662
663 // ***************************************************************************
664 // GCM UnDuel
665 // ***************************************************************************
666
667 class CHandlerContextUnDuel : public IActionHandler
668 {
669 public:
670 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
671 {
672 sendMsgToServer("DUEL:ABANDON");
673 }
674 };
675 REGISTER_ACTION_HANDLER( CHandlerContextUnDuel, "context_unduel");
676
677 // ***************************************************************************
678 // GCM PVP Challenge
679 // ***************************************************************************
680
681 class CHandlerContextPVPChallenge : public IActionHandler
682 {
683 public:
684 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
685 {
686 sendMsgToServer("PVP_CHALLENGE:ASK");
687 }
688 };
689 REGISTER_ACTION_HANDLER( CHandlerContextPVPChallenge, "context_pvp_challenge");
690
691 // ***************************************************************************
692 // GCM Un_PVP_Challenge
693 // ***************************************************************************
694
695 class CHandlerContextUnPVPChallenge : public IActionHandler
696 {
697 public:
698 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
699 {
700 sendMsgToServer("PVP_CHALLENGE:ABANDON");
701 }
702 };
703 REGISTER_ACTION_HANDLER( CHandlerContextUnPVPChallenge, "context_unpvp_challenge");
704
705 // ***************************************************************************
706 // GCM Invit
707 // ***************************************************************************
708
709 class CHandlerContextInvit : public IActionHandler
710 {
711 public:
712 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
713 {
714 // Game Specific Code
715 sendMsgToServer("TEAM:JOIN_PROPOSAL");
716 }
717 protected:
718 };
719 REGISTER_ACTION_HANDLER( CHandlerContextInvit, "context_invit");
720
721 // ***************************************************************************
722 // GCM Guild Invit
723 // ***************************************************************************
724
725 class CHandlerContextGuildInvit : public IActionHandler
726 {
727 public:
728 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
729 {
730 // Game Specific Code
731 sendMsgToServer("GUILD:INVITATION");
732 }
733 protected:
734 };
735 REGISTER_ACTION_HANDLER( CHandlerContextGuildInvit, "context_guild_invit");
736
737 // ***************************************************************************
738 // GCM Add to friend list
739 // ***************************************************************************
740 class CHandlerContextAddToFriendList : public IActionHandler
741 {
742 public:
743 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
744 {
745 CLFECOMMON::TCLEntityId trader = UserEntity->selection();
746 if (trader != CLFECOMMON::INVALID_SLOT)
747 {
748 CEntityCL *entity = EntitiesMngr.entity(trader);
749 if (entity)
750 {
751 string playerName = entity->getEntityName();
752 if (!playerName.empty())
753 {
754 PeopleInterraction.askAddContact(playerName, &PeopleInterraction.FriendList);
755 }
756 }
757 }
758 }
759 };
760 REGISTER_ACTION_HANDLER( CHandlerContextAddToFriendList, "context_add_to_friend_list");
761
762
763 // ***************************************************************************
764 // chooseSheath
765 // ***************************************************************************
766 /*
767 static void chooseSheath (ITEMFAMILY::EItemFamily eIF, string sAllSkills)
768 {
769 // Choose right sheath
770 CInterfaceManager *pIM = CInterfaceManager::getInstance();
771 CCDBNodeLeaf *pNLwrite = NLGUI::CDBManager::getInstance()->getDbProp(CWidgetManager::getInstance()->getParser()->getDefine("ui_set_active"));
772 CCDBNodeLeaf *pNLread = NLGUI::CDBManager::getInstance()->getDbProp(CWidgetManager::getInstance()->getParser()->getDefine("set_nb"));
773 sint32 nNbSheath = (sint32)pNLread->getValue64();
774 if (nNbSheath == 0) return;
775 pNLread = NLGUI::CDBManager::getInstance()->getDbProp(CWidgetManager::getInstance()->getParser()->getDefine("set_active"));
776 sint32 nActiveSheath = (sint32)pNLread->getValue64();
777 bool bFound = false;
778 for (sint32 i = 0; i < ((nNbSheath/2)+1); ++i)
779 {
780 for (sint32 j = 0; j < 2; ++j)
781 {
782 sint32 nSheathToTest;
783 if (j == 0)
784 nSheathToTest = nActiveSheath + i;
785 else
786 nSheathToTest = nActiveSheath - i;
787 while (nSheathToTest < INVENTORIES::sheath) nSheathToTest += nNbSheath;
788 while (nSheathToTest >= (INVENTORIES::sheath+nNbSheath)) nSheathToTest -= nNbSheath;
789
790 string sPath;
791 sPath = CWidgetManager::getInstance()->getParser()->getDefine("set_base") + ":" + NLMISC::toString(nSheathToTest) + ":" + CWidgetManager::getInstance()->getParser()->getDefine("set_r") + ":SHEET";
792 pNLread = NLGUI::CDBManager::getInstance()->getDbProp(sPath);
793 sint32 sheetid = (sint32)pNLread->getValue64();
794 CItemSheet *pIS = dynamic_cast<CItemSheet *>(SheetMngr.get(CSheetId(sheetid)));
795 if (pIS != NULL)
796 {
797 if (pIS->Family == eIF)
798 {
799 // YOYO: Fast search. important because skill_list is too big for "training" buton case
800 string skillList= IActionHandler::getParam (sAllSkills, "skill_list");
801 if( !skillList.empty() )
802 {
803 std::vector<string> strList;
804 NLMISC::splitString(skillList, ",", strList);
805 for(uint k=0;k<strList.size();k++)
806 {
807 static string sSkillToTrain;
808 sSkillToTrain= strList[k];
809 // remove \n,\t and spaces
810 while( !sSkillToTrain.empty() &&
811 (sSkillToTrain[0]==' ' || sSkillToTrain[0]=='\n' || sSkillToTrain[0]=='\t') )
812 sSkillToTrain.erase(0, 1);
813 // If the tool skill match the skill filter, and if the player know this skill => OK!
814 if (pIS->Tool.Skill == SKILLS::toSkill(sSkillToTrain) && playerKnowSkill(pIS->Tool.Skill) )
815 {
816 bFound = true;
817 pNLwrite->setValue64(nSheathToTest);
818 break;
819 }
820 }
821 }
822 if (bFound) break;
823 }
824 }
825 }
826 if (bFound) break;
827 }
828 }
829 */
830
831
832 // ***************************************************************************
833 // GCM Exchange
834 // ***************************************************************************
835
836 class CHandlerContextExchange : public IActionHandler
837 {
838 public:
839 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
840 {
841 // Game Specific Code
842 sendMsgToServer("EXCHANGE:PROPOSAL");
843 }
844 protected:
845 };
846 REGISTER_ACTION_HANDLER( CHandlerContextExchange, "context_exchange");
847
848 // ***************************************************************************
849 // GCM Free look
850 // ***************************************************************************
851 class CHandlerContextFreeLook : public IActionHandler
852 {
853 public:
854 void execute(CCtrlBase * /* pCaller */, const std::string &/* sParams */)
855 {
856 // Free Look Mode Activated.
857 UserControls.startFreeLook();
858 }
859 protected:
860 };
861 REGISTER_ACTION_HANDLER( CHandlerContextFreeLook, "context_free_look");
862
863 // ***************************************************************************
864 class CHandlerToggleFreeLook : public IActionHandler
865 {
866 public:
867 void execute(CCtrlBase * /* pCaller */, const std::string & /* sParams */)
868 {
869 if (UserControls.getFreeLook())
870 UserControls.stopFreeLook();
871 else
872 UserControls.startFreeLook();
873 }
874 };
875 REGISTER_ACTION_HANDLER( CHandlerToggleFreeLook, "toggle_free_look");
876
877 // ***************************************************************************
878 // GCM Move
879 // ***************************************************************************
880 class CHandlerMove : public IActionHandler
881 {
882 public:
883 void execute(CCtrlBase * /* pCaller */, const std::string &/* sParams */)
884 {
885 // Autowalk Mode Activated.
886 UserControls.autowalkState(true);
887 }
888 protected:
889 };
890 REGISTER_ACTION_HANDLER( CHandlerMove, "context_move");
891
892 // ***************************************************************************
893 // GCM Stop
894 // ***************************************************************************
895 class CHandlerStop : public IActionHandler
896 {
897 public:
898 void execute(CCtrlBase * /* pCaller */, const std::string &/* sParams */)
899 {
900 // Autowalk Mode Activated.
901 UserControls.autowalkState(false);
902 }
903 protected:
904 };
905 REGISTER_ACTION_HANDLER( CHandlerStop, "context_stop");
906
907 // ***************************************************************************
908 class CHandlerExitFreeLook : public IActionHandler
909 {
910 public:
911 void execute(CCtrlBase * /* pCaller */, const std::string &/* sParams */)
912 {
913 // Deactivate free look mode
914 UserControls.stopFreeLook();
915 }
916 protected:
917 };
918 REGISTER_ACTION_HANDLER( CHandlerExitFreeLook, "exit_free_look");
919
920 // ***************************************************************************
921 // GCM Loot Action
922 // ***************************************************************************
923 class CHandlerContextLootAction : public IActionHandler
924 {
925 public:
926 void execute(CCtrlBase * /* pCaller */, const std::string &/* sParams */)
927 {
928 NetMngr.pushPickup(UserEntity->selection(), LHSTATE::LOOTABLE);
929
930 // For loot open directly temporary inventory
931 CTempInvManager::getInstance()->open(TEMP_INV_MODE::Loot);
932 }
933 protected:
934 };
935 REGISTER_ACTION_HANDLER( CHandlerContextLootAction, "context_loot");
936
937 // ***************************************************************************
938 // GCM Quartering Action
939 // ***************************************************************************
940 class CHandlerContextHarvestAction : public IActionHandler
941 {
942 public:
943 void execute(CCtrlBase * /* pCaller */, const std::string &/* sParams */)
944 {
945 NetMngr.pushPickup(UserEntity->selection(), LHSTATE::HARVESTABLE);
946 // For quartering and forage open directly temporary inventory
947 CTempInvManager::getInstance()->open(TEMP_INV_MODE::Quarter);
948 }
949 protected:
950 };
951 REGISTER_ACTION_HANDLER( CHandlerContextHarvestAction, "context_quartering");
952
953 // ***************************************************************************
954 // GCM Forage Action
955 // ***************************************************************************
956 class CHandlerContextForageExtract : public IActionHandler
957 {
958 public:
959 void execute(CCtrlBase * /* pCaller */, const std::string &/* sParams */)
960 {
961 if (UserEntity->selection())
962 {
963 CEntityCL *pSel = EntitiesMngr.entity(UserEntity->selection());
964 if (pSel != NULL)
965 if (pSel->isForageSource())
966 UserEntity->moveToExtractionPhrase(UserEntity->selection(), MaxExtractionDistance, std::numeric_limits<uint>::max(), std::numeric_limits<uint>::max(), true);
967 }
968 }
969 };
970 REGISTER_ACTION_HANDLER( CHandlerContextForageExtract, "context_extract_rm");
971
972
973 // ***************************************************************************
974 // GCM Quit Team
975 // ***************************************************************************
976
977 class CHandlerContextQuitTeam : public IActionHandler
978 {
979 public:
980 void execute (CCtrlBase *pCaller, const std::string &sParams)
981 {
982 // directly launch the quit_team AH.
983 CInterfaceManager *pIM= CInterfaceManager::getInstance();
984 CAHManager::getInstance()->runActionHandler("quit_team",pCaller, sParams);
985 }
986 protected:
987 };
988 REGISTER_ACTION_HANDLER( CHandlerContextQuitTeam, "context_quit_team");
989
990
991 // ***************************************************************************
992 // GCM Quit Guild
993 // ***************************************************************************
994
995 class CHandlerContextQuitGuild : public IActionHandler
996 {
997 public:
998 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
999 {
1000 CInterfaceManager *pIM= CInterfaceManager::getInstance();
1001
1002 // Ask if ok before.
1003 pIM->validMessageBox(CInterfaceManager::QuestionIconMsg, CI18N::get("uiQQuitGuild"), "do_quit_guild");
1004 }
1005 protected:
1006 };
1007 REGISTER_ACTION_HANDLER( CHandlerContextQuitGuild, "context_quit_guild");
1008
1009
1010 // If Ok.
1011 class CHandlerDoQuitGuild : public IActionHandler
1012 {
1013 public:
1014 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
1015 {
1016 // Create the message for the server to execute a phrase.
1017 sendMsgToServer("GUILD:QUIT");
1018 CGuildManager::getInstance()->closeAllInterfaces();
1019
1020 if (PeopleInterraction.TheUserChat.Filter.getTargetGroup() == CChatGroup::guild)
1021 ChatMngr.updateChatModeAndButton(CChatGroup::say);
1022 }
1023 };
1024 REGISTER_ACTION_HANDLER( CHandlerDoQuitGuild, "do_quit_guild");
1025
1026
1027 // ***************************************************************************
1028 // GCM Disengage
1029 // ***************************************************************************
1030
1031 class CHandlerContextDisengage : public IActionHandler
1032 {
1033 public:
1034 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
1035 {
1036 // Disengage
1037 UserEntity->disengage();
1038 }
1039 protected:
1040
1041 };
1042 REGISTER_ACTION_HANDLER( CHandlerContextDisengage, "context_disengage");
1043
1044 // ***************************************************************************
1045 // GCM Mount
1046 // ***************************************************************************
1047
1048 class CHandlerContextMount : public IActionHandler
1049 {
1050 public:
1051 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
1052 {
1053 CEntityCL *sel = EntitiesMngr.entity(UserEntity->selection());
1054 if (sel == NULL) return;
1055
1056 // Game Specific Code
1057 CInterfaceManager *pIM = CInterfaceManager::getInstance();
1058
1059 // Look through Database the index of the mount selected
1060 for (uint32 i = 0; i < MAX_INVENTORY_ANIMAL; i++)
1061 {
1062 CCDBNodeLeaf *uidProp = NLGUI::CDBManager::getInstance()->getDbProp(toString("SERVER:PACK_ANIMAL:BEAST%d:UID", i), false);
1063 CCDBNodeLeaf *typeProp = NLGUI::CDBManager::getInstance()->getDbProp(toString("SERVER:PACK_ANIMAL:BEAST%d:TYPE", i), false);
1064 if ((uidProp != NULL) && (uidProp->getValue32() == (sint32)sel->dataSetId()) &&
1065 (typeProp != NULL) && (typeProp->getValue32() == ANIMAL_TYPE::Mount))
1066 {
1067 beastOrder("mount", toString(i+1)); // why +1 ? : dixit sendAnimalCommand in EGS : index 0 = all animals, 1 = animal 0 etc
1068 CAHManager::getInstance()->runActionHandler("animal_target", NULL, toString(i+1));
1069 UserEntity->moveTo(UserEntity->selection(),2.0,CUserEntity::None);
1070 }
1071 }
1072 }
1073 };
1074 REGISTER_ACTION_HANDLER( CHandlerContextMount, "context_mount");
1075
1076 // ***************************************************************************
1077 // GCM Unseat
1078 // ***************************************************************************
1079
1080 class CHandlerContextUnseat : public IActionHandler
1081 {
1082 public:
1083 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
1084 {
1085 // Game Specific Code
1086 beastOrder("unmount", "0");
1087
1088 // Set the database in local.
1089 if(ClientCfg.Local)
1090 {
1091 // Prepare the database to unseat
1092 IngameDbMngr.setProp("Entities:E" + toString(UserEntity->slot()) + ":P" + toString(CLFECOMMON::PROPERTY_MODE), MBEHAV::NORMAL);
1093 IngameDbMngr.setProp("Entities:E" + toString(UserEntity->slot()) + ":P" + toString(CLFECOMMON::PROPERTY_ENTITY_MOUNTED_ID), CLFECOMMON::INVALID_SLOT);
1094 IngameDbMngr.setProp("Entities:E" + toString(UserEntity->mount()) + ":P" + toString(CLFECOMMON::PROPERTY_MODE), MBEHAV::NORMAL);
1095 IngameDbMngr.setProp("Entities:E" + toString(UserEntity->mount()) + ":P" + toString(CLFECOMMON::PROPERTY_RIDER_ENTITY_ID), CLFECOMMON::INVALID_SLOT);
1096 // Read the database to unseat.
1097 CEntityCL *mount = EntitiesMngr.entity(UserEntity->mount());
1098 if(mount)
1099 {
1100 mount->updateVisualProperty(NetMngr.getCurrentServerTick()+10, CLFECOMMON::PROPERTY_MODE);
1101 mount->updateVisualProperty(NetMngr.getCurrentServerTick()+10, CLFECOMMON::PROPERTY_RIDER_ENTITY_ID);
1102 }
1103 UserEntity->updateVisualProperty(NetMngr.getCurrentServerTick()+10, CLFECOMMON::PROPERTY_MODE);
1104 UserEntity->updateVisualProperty(NetMngr.getCurrentServerTick()+10, CLFECOMMON::PROPERTY_ENTITY_MOUNTED_ID);
1105 }
1106 }
1107 protected:
1108
1109 };
1110 REGISTER_ACTION_HANDLER( CHandlerContextUnseat, "context_unseat");
1111
1112
1113 // ***************************************************************************
1114 class CHandlerContextWebPage : public IActionHandler
1115 {
1116 public:
1117 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
1118 {
1119 CInterfaceManager *pIM= CInterfaceManager::getInstance();
1120
1121 // start the npc web page
1122 CLuaManager::getInstance().executeLuaScript("game:startNpcWebPage()", true);
1123 }
1124 };
1125 REGISTER_ACTION_HANDLER( CHandlerContextWebPage, "context_web_page");
1126
1127
1128 // ***************************************************************************
1129 class CHandlerFullMap : public IActionHandler
1130 {
1131 public:
1132 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
1133 {
1134 CInterfaceManager *pIM= CInterfaceManager::getInstance();
1135
1136 CLuaManager::getInstance().executeLuaScript("game:openFullMap()", true);
1137 }
1138 };
1139 REGISTER_ACTION_HANDLER( CHandlerFullMap, "fullmap");
1140
1141
1142
1143
1144 // ***************************************************************************
1145 // GCM Mission option
1146 // ***************************************************************************
1147 class CHandlerContextMissionRing : public IActionHandler
1148 {
1149 public:
1150 void execute (CCtrlBase * /* pCaller */, const std::string &sParams)
1151 {
1152 std::string id = getParam(sParams, "id");
1153 sint idInDb;
1154 if (!fromString(id, idInDb)) return;
1155
1156 CInterfaceManager *pIM= CInterfaceManager::getInstance();
1157
1158 // get ID
1159 CCDBNodeLeaf *dbMissionId = NLGUI::CDBManager::getInstance()->getDbProp(toString("LOCAL:TARGET:CONTEXT_MENU:MISSION_RING:%d:ID", idInDb), false);
1160 if (!dbMissionId)
1161 return;
1162 uint32 missionId= dbMissionId->getValue32();
1163
1164 // send msg
1165 sendMsgToServer("RING_MISSION:MISSION_RING_SELECT", (uint32)missionId);
1166 }
1167 };
1168 REGISTER_ACTION_HANDLER(CHandlerContextMissionRing, "mission_ring");
1169
1170
1171 /**********************************************************************************************************
1172 * *
1173 * game handlers *
1174 * *
1175 ***********************************************************************************************************/
1176
1177
1178 // ***************************************************************************
1179 //quit the game
1180 class CAHQuitGame : public IActionHandler
1181 {
1182 public:
1183 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
1184 {
1185 /* todo game_exit
1186 game_exit = true;
1187 nlinfo("User Request to Quit the game"); */
1188 }
1189 };
1190 REGISTER_ACTION_HANDLER( CAHQuitGame, "quit_game");
1191
1192
1193 // ***************************************************************************
1194 //quit the game
1195 class CAHQuitRyzom : public IActionHandler
1196 {
1197 public:
1198 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
1199 {
1200 // If we are not connected, quit now
1201 if((!ConnectionReadySent) && (!FarTP.isLeavingEGS()))
1202 {
1203 game_exit = true;
1204 ryzom_exit = true;
1205 nlinfo("User Request to Quit ryzom");
1206 }
1207 else
1208 {
1209 // Don't quit but wait for server Quit
1210 game_exit_request = true;
1211 ryzom_exit_request = true;
1212
1213 const char *msgName = "CONNECTION:CLIENT_QUIT_REQUEST";
1214 CBitMemStream out;
1215 nlverify(GenericMsgHeaderMngr.pushNameToStream(msgName, out));
1216 bool bypassDisconnectionTimer = FarTP.isFastDisconnectGranted() && (!IsInRingSession); // no need on a ring shard, as it's very short
1217 out.serial(bypassDisconnectionTimer);
1218 FarTP.writeSecurityCodeForDisconnection(out); // must always be written because of msg.xml (or could have a special handler in the FS)
1219 NetMngr.push(out);
1220 //nlinfo("impulseCallBack : %s sent", msgName.c_str());
1221 }
1222 }
1223 };
1224 REGISTER_ACTION_HANDLER( CAHQuitRyzom, "quit_ryzom");
1225
1226 // ***************************************************************************
1227 //paying account for Free Trial
1228 class CAHPayingAccount : public IActionHandler
1229 {
1230 public:
1231 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
1232 {
1233 paying_account_request = FreeTrial;
1234 if(!FreeTrial)
1235 {
1236 CInterfaceManager *pIM= CInterfaceManager::getInstance();
1237 CAHManager::getInstance()->runActionHandler("quit_ryzom", NULL);
1238 }
1239 }
1240 };
1241 REGISTER_ACTION_HANDLER( CAHPayingAccount, "paying_account");
1242
1243 // ***************************************************************************
1244 //force quit the game
1245 class CAHQuitRyzomNow : public IActionHandler
1246 {
1247 public:
1248 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
1249 {
1250 if(!paying_account_already_request && FreeTrial)
1251 {
1252 paying_account_request = true;
1253 game_exit_after_paying_account_request = true;
1254 }
1255 else
1256 {
1257 game_exit = true;
1258 ryzom_exit = true;
1259 }
1260 paying_account_already_request = false;
1261
1262 //game_exit = true;
1263 //ryzom_exit = true;
1264
1265 nlinfo("User Force to Quit ryzom");
1266 }
1267 };
1268 REGISTER_ACTION_HANDLER( CAHQuitRyzomNow, "quit_ryzom_now");
1269
1270
1271 // ***************************************************************************
1272 //Abort quit the game
1273 class CAHQuitRyzomAbort : public IActionHandler
1274 {
1275 public:
1276 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
1277 {
1278 if(ClientCfg.Local)
1279 {
1280 game_exit_request = false;
1281 ryzom_exit_request = false;
1282 nlinfo("User Abort to Quit ryzom");
1283 }
1284 else
1285 {
1286 // send a message to server, thru cancel cast
1287 CInterfaceManager *pIM= CInterfaceManager::getInstance();
1288 CAHManager::getInstance()->runActionHandler("phrase_cancel_cast", NULL);
1289 }
1290 paying_account_request = false;
1291 paying_account_already_request = false;
1292 }
1293 };
1294 REGISTER_ACTION_HANDLER( CAHQuitRyzomAbort, "quit_ryzom_abort");
1295
1296 // ***************************************************************************
1297 //Abort quit the game
1298 class CAHCloseFreeTrialQuitting : public IActionHandler
1299 {
1300 public:
1301 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
1302 {
1303 CInterfaceManager *pIM= CInterfaceManager::getInstance();
1304
1305 paying_account_request = false;
1306
1307 if(game_exit_after_paying_account_request)
1308 {
1309 game_exit = true;
1310 ryzom_exit = true;
1311 game_exit_after_paying_account_request = false;
1312 }
1313 else
1314 {
1315 paying_account_already_request = true;
1316 CAHManager::getInstance()->runActionHandler("quit_ryzom", NULL);
1317 }
1318
1319 CAHManager::getInstance()->runActionHandler("leave_modal", NULL);
1320 }
1321 };
1322 REGISTER_ACTION_HANDLER( CAHCloseFreeTrialQuitting, "close_free_trial_game_quitting");
1323
1324
1325 // ***************************************************************************
1326 // quit the ring session and return to mainland Ryzom
1327 class CAHReturnToMainland : public IActionHandler
1328 {
1329 public:
1330 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
1331 {
1332 FarTP.requestReturnToPreviousSession();
1333 }
1334 };
1335 REGISTER_ACTION_HANDLER( CAHReturnToMainland, "return_to_mainland");
1336
1337 // ***************************************************************************
1338 // quit the ring session and return to character selection
1339 class CAHReselectCharacter : public IActionHandler
1340 {
1341 public:
1342 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
1343 {
1344 nlinfo("User request to reselect character");
1345 FarTP.requestReconnection();
1346 }
1347 };
1348 REGISTER_ACTION_HANDLER( CAHReselectCharacter, "reselect_character");
1349
1350 // ***************************************************************************
1351 /** Select an item in a selection group
1352 */
1353 class CSelectItemSheet : public IActionHandler
1354 {
1355 virtual void execute (CCtrlBase *pCaller, const string &/* Params */)
1356 {
1357 CDBCtrlSheet *ctrlSheet = dynamic_cast<CDBCtrlSheet *>(pCaller);
1358 if (!ctrlSheet) return;
1359 sint selectionGroup = ctrlSheet->getSelectionGroup();
1360 CInterfaceManager *im = CInterfaceManager::getInstance();
1361 const CCtrlSheetSelection &css = CWidgetManager::getInstance()->getParser()->getCtrlSheetSelection();
1362 const CSheetSelectionGroup *csg = css.getGroup(selectionGroup);
1363 if (csg && csg->isActive())
1364 {
1365 if (ctrlSheet->getSheetId() != 0)
1366 {
1367 // set the slot as the current selection
1368 CDBCtrlSheet::setCurrSelection(ctrlSheet);
1369 }
1370 else
1371 {
1372 CDBCtrlSheet::setCurrSelection(NULL);
1373 }
1374 }
1375 bool canUse = true;
1376 bool canBuild = true;
1377 bool canUseBuiltItem = true;
1378 // check if user has the level to use the item (applies to item & plans)
1379 if (ctrlSheet->getSheetCategory() == CDBCtrlSheet::Item)
1380 {
1381 if (csg && csg->getName() == "buy_selection")
1382 {
1383 const CItemSheet *is = ctrlSheet->asItemSheet();
1384 if (is)
1385 {
1386 // get the needed skill to use the item
1387 SKILLS::ESkills rs = is->getRequiredSkill();
1388 if (rs < SKILLS::unknown)
1389 {
1390 #define SKILL_PATH "SERVER:CHARACTER_INFO:SKILLS:"
1391 string path = toString(SKILL_PATH "%d:SKILL", (int) rs);
1392 CCDBNodeLeaf *nl = NLGUI::CDBManager::getInstance()->getDbProp(path,false);
1393 if (nl)
1394 {
1395 if (nl->getValue32() == 0)
1396 {
1397 canUse = false;
1398 }
1399 }
1400 }
1401
1402 // display msg in the system infos
1403 if (!canUse)
1404 {
1405 string msg = CI18N::get("msgCantUseItem");
1406 string cat = getStringCategory(msg, msg);
1407 im->displaySystemInfo(msg, cat);
1408 }
1409 if (!canBuild)
1410 {
1411 string msg = CI18N::get("msgCantBuild");
1412 string cat = getStringCategory(msg, msg);
1413 im->displaySystemInfo(msg, cat);
1414 }
1415 if (!canUseBuiltItem)
1416 {
1417 string msg = CI18N::get("msgCantUseBuiltItem");
1418 string cat = getStringCategory(msg, msg);
1419 im->displaySystemInfo(msg, cat);
1420 }
1421 }
1422 }
1423 }
1424 showItemFlags(im, canUse, canBuild, canUseBuiltItem);
1425 }
1426
1427
1428
1429 /** On the trade windows, display or not : can use item, can build item, can use built item
1430 */
1431 void showItemFlags(CInterfaceManager *im, bool canUse, bool canBuild, bool canUseBuiltItem);
1432 };
1433 REGISTER_ACTION_HANDLER (CSelectItemSheet, "select_item");
1434
1435 void CSelectItemSheet::showItemFlags(CInterfaceManager *im,bool canUse,bool canBuild,bool canUseBuiltItem)
1436 {
1437 if (!im) return;
1438 CInterfaceGroup *gr;
1439 #define BOT_CHAT_TRADE_PATH "ui:interface:bot_chat_trade:header_opened:trade_content:"
1440 gr = dynamic_cast<CInterfaceGroup *>( CWidgetManager::getInstance()->getElementFromId(BOT_CHAT_TRADE_PATH "cant_use_item"));
1441 if (gr) gr->setActive(!canUse);
1442 gr = dynamic_cast<CInterfaceGroup *>(CWidgetManager::getInstance()->getElementFromId(BOT_CHAT_TRADE_PATH "cant_use_built_item"));
1443 if (gr) gr->setActive(!canUseBuiltItem);
1444 gr = dynamic_cast<CInterfaceGroup *>(CWidgetManager::getInstance()->getElementFromId(BOT_CHAT_TRADE_PATH "cant_build_item"));
1445 if (gr) gr->setActive(!canBuild);
1446 }
1447
1448
1449 // ***************************************************************************
1450 /** Set a price in the given DB entries
1451 *
1452 */
1453 class CSetPriceInDB : public IActionHandler
1454 {
1455 virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
1456 {
1457 std::string ls = getParam(Params, "ls");
1458 std::string ms = getParam(Params, "ms");
1459 std::string bs = getParam(Params, "bs");
1460 std::string vbs = getParam(Params, "vbs");
1461 std::string value = getParam(Params, "value");
1462 if (ls.empty() || ms.empty() || bs.empty() || vbs.empty() || value.empty())
1463 {
1464 nlwarning("<CSetItemPriceInDB::execute> can't get db address for all kind of seeds, or can't get value");
1465 return;
1466 }
1467 CInterfaceExprValue price;
1468 if (!CInterfaceExpr::eval(value, price) || !price.toInteger())
1469 {
1470 nlwarning("<CSetPriceInDB::execute> : Can't evaluate price");
1471 return;
1472 }
1473 CInterfaceManager *im = CInterfaceManager::getInstance();
1474 if (price.getInteger() >= 0)
1475 {
1476 CSeeds money;
1477 money.setTotal(price.getInteger());
1478 NLGUI::CDBManager::getInstance()->getDbProp(ls)->setValue64(money.getLS());
1479 NLGUI::CDBManager::getInstance()->getDbProp(ms)->setValue64(money.getMS());
1480 NLGUI::CDBManager::getInstance()->getDbProp(bs)->setValue64(money.getBS());
1481 NLGUI::CDBManager::getInstance()->getDbProp(vbs)->setValue64(money.getVBS());
1482 }
1483 else
1484 {
1485 // undefined price
1486 NLGUI::CDBManager::getInstance()->getDbProp(ls)->setValue64(-1);
1487 NLGUI::CDBManager::getInstance()->getDbProp(ms)->setValue64(-1);
1488 NLGUI::CDBManager::getInstance()->getDbProp(bs)->setValue64(-1);
1489 NLGUI::CDBManager::getInstance()->getDbProp(vbs)->setValue64(-1);
1490 }
1491 }
1492 };
1493 REGISTER_ACTION_HANDLER (CSetPriceInDB, "set_price_in_db");
1494
1495
1496 // ***************************************************************************
1497 /** Pack animal orders
1498 */
1499 //give an order to the beast
1500 void beastOrder (const std::string &orderStr, const std::string &beastIndexStr, bool confirmFree)
1501 {
1502 uint8 order = (uint8) ANIMALS_ORDERS::stringToBeastOrder(orderStr);
1503 if (order == ANIMALS_ORDERS::UNKNOWN_BEAST_ORDER)
1504 {
1505 nlwarning("<beastOrder> : invalid beast order : %s", orderStr.c_str());
1506 return;
1507 }
1508 sint64 beastIndex;
1509 if (!CInterfaceExpr::evalAsInt(beastIndexStr, beastIndex))
1510 {
1511 nlwarning("<beastOrder> : can't read beast index");
1512 return;
1513 }
1514 // 0 is for all beasts => MAX_INVENTORY_ANIMAL is a valid selection
1515 if (beastIndex > MAX_INVENTORY_ANIMAL)
1516 {
1517 nlwarning("<beastOrder> : invalid animal index %d, maximum is %d", beastIndex, (int) MAX_INVENTORY_ANIMAL);
1518 return;
1519 }
1520
1521 // if the order is a free, and if confirm, open a message first
1522 if(order == ANIMALS_ORDERS::FREE && confirmFree)
1523 {
1524 CInterfaceManager *pIM= CInterfaceManager::getInstance();
1525 if(beastIndex==0)
1526 pIM->validMessageBox(CInterfaceManager::QuestionIconMsg, CI18N::get("uiQConfirmFreeAllAnimal"),
1527 "do_beast_free", toString(beastIndex) );
1528 else
1529 pIM->validMessageBox(CInterfaceManager::QuestionIconMsg, CI18N::get("uiQConfirmFreeAnimal"),
1530 "do_beast_free", toString(beastIndex) );
1531 }
1532 // else launch the command
1533 else
1534 {
1535 // execute the order.
1536 const char *msgName = "ANIMALS:BEAST";
1537 CBitMemStream out;
1538 if(GenericMsgHeaderMngr.pushNameToStream(msgName, out))
1539 {
1540 uint8 u8BeastIndex = (uint8) beastIndex;
1541 out.serial(u8BeastIndex); // to activate on server side
1542 // 0 -> all beasts, otherwise, the index of the beast
1543 out.serial(order);
1544 NetMngr.push(out);
1545 }
1546 else
1547 nlwarning("<beastOrder> : unknown message name : '%s'.", msgName);
1548 }
1549 }
1550
1551 // ***************************************************************************
1552 class CHandlerBeastOrder : public IActionHandler
1553 {
1554 public:
1555 virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
1556 {
1557 string orderStr = getParam(Params,"order");
1558 if( orderStr == "mount" )
1559 {
1560 // target the beast
1561 CInterfaceManager * pIM= CInterfaceManager::getInstance();
1562 string beastIndex;
1563 if( CInterfaceExpr::evalAsString(getParam(Params,"beast_index"), beastIndex) )
1564 {
1565 CAHManager::getInstance()->runActionHandler("animal_target", NULL, beastIndex);
1566 }
1567 // move to the beast
1568 UserEntity->moveTo(UserEntity->selection(),3.0,CUserEntity::Mount);
1569 }
1570 else
1571 beastOrder (getParam(Params,"order"), getParam(Params,"beast_index"), true);
1572 }
1573 };
1574 REGISTER_ACTION_HANDLER( CHandlerBeastOrder, "beast_order")
1575
1576
1577 // ***************************************************************************
1578 class CHandlerDoBeastFree : public IActionHandler
1579 {
1580 public:
1581 virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
1582 {
1583 // free with no confirm
1584 if (!UserEntity->isBusy())
1585 beastOrder ("free", Params, false);
1586 }
1587 };
1588 REGISTER_ACTION_HANDLER( CHandlerDoBeastFree, "do_beast_free")
1589
1590
1591 // ***************************************************************************
1592 // Change Possible Orders
1593 class CHandlerAnimalMenuOption : public IActionHandler
1594 {
1595 public:
1596 virtual void execute (CCtrlBase *pCaller, const string &/* Params */)
1597 {
1598 CInterfaceManager *pIM = CInterfaceManager::getInstance();
1599 CInterfaceGroup *pMenu= dynamic_cast<CInterfaceGroup*>(pCaller);
1600 if(!pMenu) return;
1601
1602 CViewTextMenu *pFollow = dynamic_cast<CViewTextMenu*>(pMenu->getView("follow"));
1603 CViewTextMenu *pStop = dynamic_cast<CViewTextMenu*>(pMenu->getView("stop"));
1604 CViewTextMenu *pFree = dynamic_cast<CViewTextMenu*>(pMenu->getView("free"));
1605 CViewTextMenu *pEnterStable = dynamic_cast<CViewTextMenu*>(pMenu->getView("enter_stable"));
1606 CViewTextMenu *pLeaveStable = dynamic_cast<CViewTextMenu*>(pMenu->getView("leave_stable"));
1607 CViewTextMenu *pEnterBag = dynamic_cast<CViewTextMenu*>(pMenu->getView("enter_bag"));
1608 CViewTextMenu *pLeaveBag = dynamic_cast<CViewTextMenu*>(pMenu->getView("leave_bag"));
1609 CViewTextMenu *pMount = dynamic_cast<CViewTextMenu*>(pMenu->getView("mount"));
1610 CViewTextMenu *pUnseat = dynamic_cast<CViewTextMenu*>(pMenu->getView("unseat"));
1611
1612 // Get the animal Selected. 0 for Alls, 1,2,3,4,5 for each pack animal
1613 CCDBNodeLeaf *node= NLGUI::CDBManager::getInstance()->getDbProp("UI:BEAST_SELECTED", false);
1614 if(!node) return;
1615 sint selected= node->getValue32();
1616
1617 // Enable menu entries according to each beast
1618 // All Mode
1619 if(selected==0)
1620 {
1621 // Test all menu option ('OR': display even if *all* animals don't comply with the commands)
1622 for(uint i=0;i<MAX_INVENTORY_ANIMAL;i++)
1623 {
1624 // Get the entity if it is in vision
1625 CEntityCL* selectedAnimalInVision = NULL;
1626 CCDBNodeLeaf *uidProp = NLGUI::CDBManager::getInstance()->getDbProp(toString("SERVER:PACK_ANIMAL:BEAST%d:UID", i), false);
1627 if ( uidProp )
1628 {
1629 CLFECOMMON::TClientDataSetIndex datasetIndex = uidProp->getValue32();
1630 selectedAnimalInVision = EntitiesMngr.getEntityByCompressedIndex( datasetIndex );
1631 }
1632
1633 // Enable menu items
1634 testMenuOptionForPackAnimal(selectedAnimalInVision, i, (i==0),
1635 pFollow, pStop, pFree, pEnterStable, pLeaveStable, pMount, pUnseat, pEnterBag, pLeaveBag);
1636 }
1637 }
1638 else if(selected>=1 && selected<=MAX_INVENTORY_ANIMAL)
1639 {
1640 // Get the entity if it is in vision
1641 CEntityCL* selectedAnimalInVision = NULL;
1642 CCDBNodeLeaf *uidProp = NLGUI::CDBManager::getInstance()->getDbProp(toString("SERVER:PACK_ANIMAL:BEAST%d:UID", selected-1), false);
1643 if ( uidProp )
1644 {
1645 CLFECOMMON::TClientDataSetIndex datasetIndex = uidProp->getValue32();
1646 selectedAnimalInVision = EntitiesMngr.getEntityByCompressedIndex( datasetIndex );
1647 }
1648
1649 // Enable menu items
1650 testMenuOptionForPackAnimal(selectedAnimalInVision, selected-1, true,
1651 pFollow, pStop, pFree, pEnterStable, pLeaveStable, pMount, pUnseat, pEnterBag, pLeaveBag);
1652 }
1653 }
1654 };
1655 REGISTER_ACTION_HANDLER( CHandlerAnimalMenuOption, "animal_menu_option")
1656
1657
1658 // ***************************************************************************
1659 // Target an animal
1660 class CHandlerAnimalTarget : public IActionHandler
1661 {
1662 void execute (CCtrlBase * /* pCaller */, const std::string &sParams)
1663 {
1664 CInterfaceManager *pIM= CInterfaceManager::getInstance();
1665
1666 // retrieve the index of the animal
1667 sint animalIndex = 0;
1668 bool ok = false;
1669 // If comes from the button, get direct index
1670 if( !sParams.empty() )
1671 {
1672 fromString(sParams, animalIndex);
1673 ok = true;
1674 }
1675
1676 // If success to get the animal id
1677 if(ok)
1678 {
1679 // Get the animal id.
1680 CLFECOMMON::TClientDataSetIndex entityUid= CLFECOMMON::INVALID_CLIENT_DATASET_INDEX;
1681
1682 if(animalIndex>=1 && animalIndex<=MAX_INVENTORY_ANIMAL)
1683 {
1684 CCDBNodeLeaf *prop = NLGUI::CDBManager::getInstance()->getDbProp(toString("SERVER:PACK_ANIMAL:BEAST%d:UID", animalIndex-1), false);
1685 if(prop) entityUid= prop->getValue32();
1686 }
1687
1688 if(entityUid != CLFECOMMON::INVALID_CLIENT_DATASET_INDEX)
1689 {
1690 // get the entity by its received UID
1691 CEntityCL *entity= EntitiesMngr.getEntityByCompressedIndex(entityUid);
1692 if(entity)
1693 // Select this entity.
1694 UserEntity->selection(entity->slot());
1695 else
1696 {
1697 // the entity is not in vision, can't select it
1698 pIM->displaySystemInfo(CI18N::get("uiAnimalSelectNotInVision"), "CHK");
1699 }
1700 }
1701 }
1702 }
1703 };
1704 REGISTER_ACTION_HANDLER( CHandlerAnimalTarget, "animal_target" );
1705
1706
1707 // ***************************************************************************
1708 // Open an animal inventory
1709 class CHandlerAnimalOpenInventory : public IActionHandler
1710 {
1711 void execute (CCtrlBase * /* pCaller */, const std::string &sParams)
1712 {
1713 CInterfaceManager *pIM= CInterfaceManager::getInstance();
1714
1715 // retrieve the index of the animal
1716 sint animalIndex= 0;
1717 bool ok= false;
1718 // If comes from the button, get direct index
1719 if( !sParams.empty() )
1720 {
1721 fromString(sParams, animalIndex);
1722 ok= true;
1723 }
1724
1725 // If success to get the animal id
1726 if(ok)
1727 {
1728 if(animalIndex>=1 && animalIndex<=MAX_INVENTORY_ANIMAL)
1729 {
1730 // show/hide the inventory
1731 CInterfaceElement *group= CWidgetManager::getInstance()->getElementFromId(toString("ui:interface:inv_pa%d", animalIndex-1) );
1732
1733 if(group) group->setActive(!group->getActive());
1734 }
1735 }
1736 }
1737 };
1738 REGISTER_ACTION_HANDLER( CHandlerAnimalOpenInventory, "animal_open_inventory" );
1739
1740
1741 // ***************************************************************************
1742 // closeGroup Helper
1743 // ***************************************************************************
1744 static void closeGroup(const string &groupName)
1745 {
1746 CInterfaceManager *pIM = CInterfaceManager::getInstance();
1747 CInterfaceGroup *pIG = dynamic_cast<CInterfaceGroup *>(CWidgetManager::getInstance()->getElementFromId(groupName));
1748 if (pIG == NULL) return;
1749 pIG->setActive(false);
1750 }
1751
1752 // ***************************************************************************
1753 // ACCEPT TEAM INVITE
1754 // ***************************************************************************
1755
1756 class CHandlerAcceptTeamInvitation : public IActionHandler
1757 {
1758 public:
1759 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
1760 {
1761 closeGroup("ui:interface:join_team_proposal");
1762 sendMsgToServer("TEAM:JOIN");
1763 }
1764 protected:
1765
1766 };
1767 REGISTER_ACTION_HANDLER( CHandlerAcceptTeamInvitation, "accept_team_invitation");
1768
1769 // ***************************************************************************
1770 // REFUSE TEAM INVITE
1771 // ***************************************************************************
1772
1773 class CHandlerRefuseTeamInvitation : public IActionHandler
1774 {
1775 public:
1776 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
1777 {
1778 closeGroup("ui:interface:join_team_proposal");
1779 sendMsgToServer("TEAM:JOIN_PROPOSAL_DECLINE");
1780 }
1781 protected:
1782
1783 };
1784 REGISTER_ACTION_HANDLER( CHandlerRefuseTeamInvitation, "refuse_team_invitation");
1785
1786 // ***************************************************************************
1787 // ACCEPT GUILD INVITE
1788 // ***************************************************************************
1789
1790 class CHandlerAcceptGuildInvitation : public IActionHandler
1791 {
1792 public:
1793 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
1794 {
1795 sendMsgToServer("GUILD:ACCEPT_INVITATION");
1796 CGuildManager::getInstance()->quitJoinProposal();
1797 }
1798
1799 };
1800 REGISTER_ACTION_HANDLER( CHandlerAcceptGuildInvitation, "accept_guild_invitation");
1801
1802 // ***************************************************************************
1803 // REFUSE GUILD INVITE
1804 // ***************************************************************************
1805
1806 class CHandlerRefuseGuildInvitation : public IActionHandler
1807 {
1808 public:
1809 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
1810 {
1811 sendMsgToServer("GUILD:REFUSE_INVITATION");
1812 CGuildManager::getInstance()->quitJoinProposal();
1813 }
1814 };
1815 REGISTER_ACTION_HANDLER( CHandlerRefuseGuildInvitation, "refuse_guild_invitation");
1816
1817 // ***************************************************************************
1818 // ACCEPT DUEL INVITE
1819 // ***************************************************************************
1820
1821 class CHandlerAcceptDuelInvitation : public IActionHandler
1822 {
1823 public:
1824 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
1825 {
1826 closeGroup("ui:interface:join_duel_proposal");
1827 sendMsgToServer("DUEL:ACCEPT");
1828 }
1829
1830 };
1831 REGISTER_ACTION_HANDLER( CHandlerAcceptDuelInvitation, "accept_duel_invitation");
1832
1833 // ***************************************************************************
1834 // REFUSE DUEL INVITE
1835 // ***************************************************************************
1836
1837 class CHandlerRefuseDuelInvitation : public IActionHandler
1838 {
1839 public:
1840 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
1841 {
1842 closeGroup("ui:interface:join_duel_proposal");
1843 sendMsgToServer("DUEL:REFUSE");
1844 }
1845 };
1846 REGISTER_ACTION_HANDLER( CHandlerRefuseDuelInvitation, "refuse_duel_invitation");
1847
1848 // ***************************************************************************
1849 // ACCEPT PVP CHALLENGE INVITE
1850 // ***************************************************************************
1851
1852 class CHandlerAcceptPVPChallengeInvitation : public IActionHandler
1853 {
1854 public:
1855 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
1856 {
1857 closeGroup("ui:interface:join_pvp_challenge_proposal");
1858 sendMsgToServer("PVP_CHALLENGE:ACCEPT");
1859 }
1860
1861 };
1862 REGISTER_ACTION_HANDLER( CHandlerAcceptPVPChallengeInvitation, "accept_pvp_challenge_invitation");
1863
1864 // ***************************************************************************
1865 // REFUSE PVP CHALLENGE INVITE
1866 // ***************************************************************************
1867
1868 class CHandlerRefusePVPChallengeInvitation : public IActionHandler
1869 {
1870 public:
1871 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
1872 {
1873 closeGroup("ui:interface:join_pvp_challenge_proposal");
1874 sendMsgToServer("PVP_CHALLENGE:REFUSE");
1875 }
1876 };
1877 REGISTER_ACTION_HANDLER( CHandlerRefusePVPChallengeInvitation, "refuse_pvp_challenge_invitation");
1878
1879 // ***************************************************************************
1880 // CHOOSE PVP CLAN
1881 // ***************************************************************************
1882 /*
1883 class CHandlerChoosePVPClan : public IActionHandler
1884 {
1885 public:
1886 virtual void execute (CCtrlBase *pCaller, const string &Params)
1887 {
1888 closeGroup("ui:interface:join_pvp_clan_proposal");
1889
1890 uint8 clan = 0;
1891 if( Params == "neutral" )
1892 clan = 0;
1893 else if( Params == "clan1" )
1894 clan = 1;
1895 else if( Params == "clan2" )
1896 clan = 2;
1897
1898 sendMsgToServer("PVP_VERSUS:CLAN", clan);
1899 }
1900 };
1901 REGISTER_ACTION_HANDLER( CHandlerChoosePVPClan, "pvp_clan_join");
1902 */
1903
1904 // ***************************************************************************
1905 // Launch Bug Reporting Tool
1906 // ***************************************************************************
1907
1908 class CAHLaunchBugReport : public IActionHandler
1909 {
1910 public:
1911 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
1912 {
1913 if (ClientCfg.Light)
1914 {
1915 vector<string> v;
1916 CWidgetManager::getInstance()->runProcedure ("proc_reset_interface", NULL, v);
1917
1918 //CInterfaceManager::getInstance()->launchContextMenuInGame("ui:interface:game_context_menu");
1919 }
1920 ICommand::execute("bugReport 80", g_log);
1921 }
1922 };
1923 REGISTER_ACTION_HANDLER( CAHLaunchBugReport, "launch_bug_report");
1924
1925 // ***************************************************************************
1926 // Launch Help Tool
1927 // ***************************************************************************
1928
1929 class CAHLaunchHelp : public IActionHandler
1930 {
1931 public:
1932
1933 virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
1934 {
1935 CInterfaceManager *pIM = CInterfaceManager::getInstance();
1936
1937 string url = getParam (Params, "url");
1938 string helpContainer = getParam (Params, "help_container");
1939 if (helpContainer.empty ())
1940 helpContainer = "ui:interface:help_browser";
1941
1942 // open the help browser
1943 CInterfaceElement *pIG= CWidgetManager::getInstance()->getElementFromId(helpContainer);
1944 if(pIG)
1945 pIG->setActive(true);
1946
1947 // browse the url
1948 CAHManager::getInstance()->runActionHandler("browse", NULL, "name="+helpContainer+":content:html|url="+url);
1949 }
1950 };
1951 REGISTER_ACTION_HANDLER( CAHLaunchHelp, "launch_help");
1952
1953 // ***************************************************************************
1954 static bool findInterfacePath(string &sPath, CCtrlBase *pCaller)
1955 {
1956 if (sPath.rfind(':') == string::npos)
1957 {
1958 if (pCaller == NULL) return false;
1959 sPath = pCaller->getId() + ":" + sPath;
1960 }
1961 else
1962 {
1963 CInterfaceManager *pIM = CInterfaceManager::getInstance();
1964 string elt = sPath.substr(0,sPath.rfind(':'));
1965 CInterfaceElement *pIE;
1966 if (pCaller != NULL)
1967 pIE = CWidgetManager::getInstance()->getElementFromId(pCaller->getId(), elt);
1968 else
1969 pIE = CWidgetManager::getInstance()->getElementFromId(elt);
1970 if (pIE == NULL) return false;
1971 sPath = pIE->getId() + ":" + sPath.substr(sPath.rfind(':')+1,sPath.size());
1972 }
1973 return true;
1974 }
1975
1976 // ***************************************************************************
1977 // TARGET NAME AND TITLE MANAGEMENT
1978 // ***************************************************************************
1979
1980 // Callbacks that check that while we are waiting for the string to display the
1981 // user has not changed its target
1982
1983 // *** check for user selection and remove title
1984 class CSPPRemoveTitleAndCheckSelection : public CStringPostProcessRemoveTitle
1985 {
1986 public:
1987
1988 sint32 Slot;
1989
1990 bool cbIDStringReceived(string &inout)
1991 {
1992 if (UserEntity != NULL)
1993 {
1994 if (UserEntity->selection() == Slot)
1995 {
1996 string copyInout = inout;
1997 CStringPostProcessRemoveTitle::cbIDStringReceived(inout);
1998 if (inout.empty())
1999 {
2000 CEntityCL *entity = EntitiesMngr.entity(Slot);
2001 CCharacterCL *pChar = dynamic_cast<CCharacterCL*>(entity);
2002 bool womanTitle = false;
2003 if (pChar != NULL)
2004 womanTitle = pChar->getGender() == GSGENDER::female;
2005
2006 copyInout = STRING_MANAGER::CStringManagerClient::getTitleLocalizedName(CEntityCL::getTitleFromName(copyInout), womanTitle);
2007
2008 // Sometimes translation contains another title
2009 string::size_type pos = copyInout.find('$');
2010 if (pos != string::npos)
2011 {
2012 copyInout = STRING_MANAGER::CStringManagerClient::getTitleLocalizedName(CEntityCL::getTitleFromName(copyInout), womanTitle);
2013 }
2014
2015 CStringPostProcessRemoveTitle::cbIDStringReceived(copyInout);
2016 inout = copyInout;
2017 }
2018
2019 return true;
2020 }
2021 }
2022
2023 return false;
2024 }
2025 };
2026
2027 // *** check for user selection and remove name (keep title)
2028 class CSPPRemoveNameAndCheckSelection : public CStringPostProcessRemoveName
2029 {
2030 public:
2031
2032 sint32 Slot;
2033
2034 bool cbIDStringReceived(string &inout)
2035 {
2036 if (UserEntity != NULL)
2037 {
2038 if (UserEntity->selection() == Slot)
2039 {
2040 CEntityCL *entity = EntitiesMngr.entity(Slot);
2041 CCharacterCL *pChar = dynamic_cast<CCharacterCL*>(entity);
2042 if (pChar != NULL)
2043 {
2044 const CCharacterSheet *pSheet = pChar->getSheet();
2045 if (pSheet != NULL)
2046 {
2047 string sFame = pSheet->getFame();
2048 if (strnicmp(sFame.c_str(),"tribe_",6)==0)
2049 {
2050 inout = STRING_MANAGER::CStringManagerClient::getFactionLocalizedName(sFame);
2051 return true; // return tribe name
2052 }
2053 }
2054 Woman = pChar->getGender() == GSGENDER::female;
2055 }
2056
2057 CStringPostProcessRemoveName::cbIDStringReceived(inout);
2058
2059 return true; // return title
2060 }
2061 }
2062 return false;
2063 }
2064 };
2065
2066 // *** called when target change or target name change
2067 class CActionHandlerSetTargetName : public IActionHandler
2068 {
2069 virtual void execute (CCtrlBase *pCaller, const string &Params)
2070 {
2071 string sSlot = getParam(Params,"slot");
2072 string sNameTarget = getParam(Params,"target");
2073 string sTitleTarget = getParam(Params,"title");
2074
2075 if (sSlot.empty()) return;
2076
2077 if (!findInterfacePath(sNameTarget, pCaller)) return;
2078 findInterfacePath(sTitleTarget, pCaller);
2079
2080 CInterfaceExprValue evValue;
2081 if (CInterfaceExpr::eval(sSlot, evValue, NULL))
2082 {
2083 sint32 nSlot = (sint32)evValue.getInteger();
2084
2085 string TargetName;
2086 string TargetTitle;
2087
2088 // Get from nSlot
2089 if (nSlot > -1)
2090 {
2091 CInterfaceManager *pIM = CInterfaceManager::getInstance();
2092 // uint32 nDBid = NLGUI::CDBManager::getInstance()->getDbProp("SERVER:Entities:E"+toString(nSlot)+":P6")->getValue32();
2093 uint32 nDBid = 0;
2094 if (nSlot < sint32(EntitiesMngr.entities().size()) && EntitiesMngr.entities()[nSlot] != NULL)
2095 {
2096 nDBid = EntitiesMngr.entities()[nSlot]->getNameId();
2097 }
2098
2099 if (nDBid != 0)
2100 {
2101 CSPPRemoveTitleAndCheckSelection *pSPPRT = new CSPPRemoveTitleAndCheckSelection;
2102 pSPPRT->Slot = nSlot;
2103 CSPPRemoveNameAndCheckSelection *pSPPRN = new CSPPRemoveNameAndCheckSelection;
2104 pSPPRN->Slot = nSlot;
2105 pIM->addServerID(sNameTarget, nDBid, pSPPRT);
2106 pIM->addServerID(sTitleTarget, nDBid, pSPPRN);
2107 }
2108 else
2109 {
2110 CEntityCL *pE = EntitiesMngr.entity(nSlot);
2111 if (pE != NULL)
2112 {
2113 TargetName = pE->getDisplayName();
2114 TargetTitle = pE->getTitle();
2115 }
2116 }
2117 }
2118 // Set to target
2119 CInterfaceExprValue evUCStr;
2120 TargetName = STRING_MANAGER::CStringManagerClient::getLocalizedName(TargetName);
2121 evUCStr.setString(TargetName);
2122 CInterfaceLink::setTargetProperty(sNameTarget, evUCStr);
2123 evUCStr.setString(TargetTitle);
2124 CInterfaceLink::setTargetProperty(sTitleTarget, evUCStr);
2125 }
2126 }
2127 };
2128 REGISTER_ACTION_HANDLER (CActionHandlerSetTargetName, "set_target_name");
2129
2130 // ***************************************************************************
2131 class CActionHandlerSetTargetForceRegionLevel: public IActionHandler
2132 {
2133 virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
2134 {
2135 string sSlot = getParam(Params,"slot");
2136 string sTargetRegion = getParam(Params,"targetRegion");
2137 string sTargetLevel = getParam(Params,"targetLevel");
2138
2139 // Access UI elements
2140 if (sSlot.empty()) return;
2141 CInterfaceManager *pIM = CInterfaceManager::getInstance();
2142 CViewBitmap *pVBR = dynamic_cast<CViewBitmap*>(CWidgetManager::getInstance()->getElementFromId(sTargetRegion));
2143 if (pVBR == NULL)
2144 return;
2145 CViewBitmap *pVBL = dynamic_cast<CViewBitmap*>(CWidgetManager::getInstance()->getElementFromId(sTargetLevel));
2146 if (pVBL == NULL)
2147 return;
2148 CInterfaceExprValue evValue;
2149 if (!CInterfaceExpr::eval(sSlot, evValue, NULL))
2150 return;
2151 sint32 nSlot = (sint32)evValue.getInteger();
2152 CCtrlBase *pTooltip = dynamic_cast<CCtrlBase*>(CWidgetManager::getInstance()->getElementFromId("ui:interface:target:header_opened:force"));
2153
2154 // Access target entity
2155 CEntityCL *pE = NULL;
2156 if ( (nSlot == -1) || ((pE = EntitiesMngr.entity(nSlot)) == NULL) )
2157 {
2158 // If untargetted, clear
2159 pVBL->setTexture(string());
2160 pVBR->setColor(CRGBA(0,0,0,0));
2161
2162 if (pTooltip)
2163 pTooltip->setDefaultContextHelp(std::string());
2164
2165 return;
2166 }
2167
2168 sint nLevelForce;
2169 sint nForceRegion;
2170 if ( pE->isPlayer() )
2171 {
2172 // Player => deduce RegionForce & ForceLevel from the database
2173 CCDBNodeLeaf *pDbTargetUid = NLGUI::CDBManager::getInstance()->getDbProp( CWidgetManager::getInstance()->getParser()->getDefine("target_uid") );
2174 if ( ! pDbTargetUid )
2175 return;
2176 // Hide the target level if the USER is not in PVP FACTION
2177 // Hide the target level if the TARGET is not in PVP FACTION
2178 // Also, hide it If the database is not in sync with the local target slot
2179 if (!UserEntity || !(UserEntity->getPvpMode()&PVP_MODE::PvpZoneFaction) ||
2180 !(pE->getPvpMode()&PVP_MODE::PvpZoneFaction) ||
2181 pE->dataSetId() != (CLFECOMMON::TClientDataSetIndex)pDbTargetUid->getValue32() )
2182 {
2183 pVBL->setTexture(string());
2184 pVBR->setColor(CRGBA(0,0,0,0));
2185
2186 if (pTooltip)
2187 pTooltip->setDefaultContextHelp(CI18N::get("uittTargetUnknown"));
2188
2189 return;
2190 }
2191 CCDBNodeLeaf *pDbPlayerLevel = NLGUI::CDBManager::getInstance()->getDbProp( CWidgetManager::getInstance()->getParser()->getDefine("target_player_level") );
2192 if ( ! pDbPlayerLevel )
2193 return;
2194 sint nLevel = pDbPlayerLevel->getValue32();
2195 if ( nLevel < 250 )
2196 {
2197 nLevelForce = ((nLevel % 50) * 5 / 50) + 1;
2198 nForceRegion = (nLevel < 20) ? 1 : (nLevel / 50) + 2;
2199 }
2200 else
2201 {
2202 nLevelForce = 6; // same as named creatures
2203 nForceRegion = 8;
2204 }
2205 }
2206 else
2207 {
2208 // Creature => RegionForce & ForceLevel are in its sheet
2209 CCharacterSheet *pCS = dynamic_cast<CCharacterSheet*>(SheetMngr.get(pE->sheetId()));
2210 if (pCS == NULL || pCS->RegionForce==-1)
2211 {
2212 pVBL->setTexture(string());
2213 pVBR->setColor(CRGBA(0,0,0,0));
2214
2215 if (pTooltip)
2216 pTooltip->setDefaultContextHelp(std::string());
2217
2218 return;
2219 }
2220
2221 nForceRegion = pCS->RegionForce;
2222 nLevelForce = pCS->ForceLevel;
2223 }
2224
2225 // Set color
2226 if (nForceRegion > 6) nForceRegion = 6;
2227 if (nForceRegion < 1) nForceRegion = 1;
2228 CRGBA col = CInterfaceElement::convertColor(CWidgetManager::getInstance()->getParser()->getDefine("region_force_"+toString(nForceRegion)).c_str());
2229 pVBR->setColor(col);
2230
2231 // Set texture
2232 if (nLevelForce > 8) nLevelForce = 8;
2233 if (nLevelForce < 1) nLevelForce = 1;
2234 string sTexture = CWidgetManager::getInstance()->getParser()->getDefine("force_level_"+toString(nLevelForce));
2235 pVBL->setTexture(sTexture);
2236
2237 // Set tooltip
2238 CCtrlBase *tooltip = dynamic_cast<CCtrlBase*>(CWidgetManager::getInstance()->getElementFromId("ui:interface:target:header_opened:force"));
2239 if (tooltip)
2240 {
2241 string str;
2242
2243 if (nForceRegion == 1)
2244 nForceRegion = 2;
2245
2246 // Normal
2247 if (nLevelForce < 6)
2248 {
2249 sint min = (nForceRegion-2) * 50 + (nLevelForce-1) * 10 + 1;
2250 sint max = (nForceRegion-2) * 50 + nLevelForce * 10;
2251
2252 str= CI18N::get("uittTargetLevel");
2253 strFindReplace(str, "%min", toString(min));
2254 strFindReplace(str, "%max", toString(max));
2255 }
2256 // Boss
2257 else if (nLevelForce == 8)
2258 {
2259 sint n = (nForceRegion-1) * 50;
2260 if (pE->isNPC())
2261 str= CI18N::get("uittTargetGuardBoss");
2262 else
2263 str= CI18N::get("uittTargetBoss");
2264 strFindReplace(str, "%n", toString("%d", n) );
2265 }
2266 // Named
2267 else
2268 {
2269 sint n = (nForceRegion-1) * 50;
2270 str= CI18N::get("uittTargetNamed");
2271 strFindReplace(str, "%n", toString("%d", n) );
2272 }
2273
2274 tooltip->setDefaultContextHelp(str);
2275 }
2276 }
2277 };
2278 REGISTER_ACTION_HANDLER (CActionHandlerSetTargetForceRegionLevel, "set_force_region_level");
2279
2280 // ***************************************************************************
2281 class CAHUpdateCurrentMode : public IActionHandler
2282 {
2283 virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
2284 {
2285 string sValue = getParam(Params,"value");
2286 string sDBLink = getParam(Params,"dblink");
2287 CInterfaceManager *pIM = CInterfaceManager::getInstance();
2288 CCDBNodeLeaf *pNL = NLGUI::CDBManager::getInstance()->getDbProp(sDBLink, false);
2289 if (pNL == NULL) return;
2290
2291 CInterfaceExprValue eVal;
2292 if (!CInterfaceExpr::eval(sValue, eVal, NULL)) return;
2293
2294 sint32 nNewMode = (sint32)eVal.getInteger();
2295
2296 sint32 nModeMinInf, nModeMaxInf, nModeMinLab, nModeMaxLab, nModeMinKey, nModeMaxKey;
2297 fromString(CWidgetManager::getInstance()->getParser()->getDefine("mode_min_info"), nModeMinInf);
2298 fromString(CWidgetManager::getInstance()->getParser()->getDefine("mode_max_info"), nModeMaxInf);
2299 fromString(CWidgetManager::getInstance()->getParser()->getDefine("mode_min_lab"), nModeMinLab);
2300 fromString(CWidgetManager::getInstance()->getParser()->getDefine("mode_max_lab"), nModeMaxLab);
2301 fromString(CWidgetManager::getInstance()->getParser()->getDefine("mode_min_keys"), nModeMinKey);
2302 fromString(CWidgetManager::getInstance()->getParser()->getDefine("mode_max_keys"), nModeMaxKey);
2303
2304 sint32 nMode = 0;
2305 if ((nNewMode >= nModeMinInf) && (nNewMode <= nModeMaxInf))
2306 nMode = 1;
2307 if ((nNewMode >= nModeMinLab) && (nNewMode <= nModeMaxLab))
2308 nMode = 2;
2309 if ((nNewMode >= nModeMinKey) && (nNewMode <= nModeMaxKey))
2310 nMode = 3;
2311
2312
2313 if (nNewMode != 0)
2314 if (nNewMode == pNL->getValue32())
2315 {
2316 // We have pushed 2 times the same button
2317 nNewMode ++;
2318 if (nMode == 1)
2319 {
2320 if (nNewMode > nModeMaxInf) nNewMode = nModeMinInf;
2321 }
2322 else if (nMode == 2)
2323 {
2324 if (nNewMode > nModeMaxLab) nNewMode = nModeMinLab;
2325 }
2326 else if (nMode == 3)
2327 {
2328 if (nNewMode > nModeMaxKey) nNewMode = nModeMinKey;
2329 }
2330 }
2331
2332 // Found the first active entry in db
2333 if (nMode == 2)
2334 {
2335 bool bFound = false;
2336 while (!bFound)
2337 {
2338 CCDBNodeLeaf *pIntFlags = NLGUI::CDBManager::getInstance()->getDbProp("SERVER:INTERFACES:FLAGS", false);
2339 if (pIntFlags == NULL) return;
2340 sint64 nIntFlags = pIntFlags->getValue64();
2341
2342 sint32 tmpMode;
2343
2344 // Is NewMode entry active ?
2345 fromString(CWidgetManager::getInstance()->getParser()->getDefine("mode_magic"), tmpMode);
2346 if (nNewMode == tmpMode)
2347 if ((nIntFlags & (1<<INTERFACE_FLAGS::Magic)) != 0)
2348 bFound = true;
2349
2350 if (!bFound)
2351 {
2352 fromString(CWidgetManager::getInstance()->getParser()->getDefine("mode_combat"), tmpMode);
2353 if (nNewMode == tmpMode)
2354 if ((nIntFlags & (1<<INTERFACE_FLAGS::Combat)) != 0)
2355 bFound = true;
2356 }
2357
2358 if (!bFound)
2359 {
2360 fromString(CWidgetManager::getInstance()->getParser()->getDefine("mode_faber_create"), tmpMode);
2361 if (nNewMode == tmpMode)
2362 if ((nIntFlags & (1<<INTERFACE_FLAGS::FaberCreate)) != 0)
2363 bFound = true;
2364 }
2365
2366 if (!bFound)
2367 {
2368 fromString(CWidgetManager::getInstance()->getParser()->getDefine("mode_faber_repair"), tmpMode);
2369 if (nNewMode == tmpMode)
2370 if ((nIntFlags & (1<<INTERFACE_FLAGS::FaberRepair)) != 0)
2371 bFound = true;
2372 }
2373
2374 if (!bFound)
2375 {
2376 fromString(CWidgetManager::getInstance()->getParser()->getDefine("mode_faber_refine"), tmpMode);
2377 if (nNewMode == tmpMode)
2378 if ((nIntFlags & (1<<INTERFACE_FLAGS::FaberRefine)) != 0)
2379 bFound = true;
2380 }
2381
2382 if (!bFound)
2383 {
2384 fromString(CWidgetManager::getInstance()->getParser()->getDefine("mode_commerce"), tmpMode);
2385 if (nNewMode == tmpMode)
2386 if ((nIntFlags & (1<<INTERFACE_FLAGS::Commerce)) != 0)
2387 bFound = true;
2388 }
2389
2390 if (!bFound)
2391 {
2392 fromString(CWidgetManager::getInstance()->getParser()->getDefine("mode_macros"), tmpMode);
2393 if (nNewMode == tmpMode)
2394 bFound = true; // Not in DB !!!
2395 }
2396
2397 if (!bFound)
2398 {
2399 fromString(CWidgetManager::getInstance()->getParser()->getDefine("mode_special_labo"), tmpMode);
2400 if (nNewMode == tmpMode)
2401 if ((nIntFlags & (1<<INTERFACE_FLAGS::Special)) != 0)
2402 bFound = true;
2403 }
2404
2405 if (!bFound)
2406 {
2407 nNewMode++;
2408 if (nNewMode > nModeMaxLab) nNewMode = nModeMinLab;
2409 if (nNewMode == pNL->getValue32()) return;
2410 }
2411 }
2412 }
2413
2414 pNL->setValue32(nNewMode);
2415 }
2416 };
2417 REGISTER_ACTION_HANDLER (CAHUpdateCurrentMode, "update_current_mode");
2418
2419 // ***************************************************************************
2420 class CAHToggleChat : public IActionHandler
2421 {
2422 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
2423 {
2424 ShowInterface = !ShowInterface;
2425 }
2426 };
2427 REGISTER_ACTION_HANDLER (CAHToggleChat, "toggle_chat");
2428
2429 // ***************************************************************************
2430 class CAHToggleHelp : public IActionHandler
2431 {
2432 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
2433 {
2434 #if FINAL_VERSION
2435 if( ClientCfg.Local || hasPrivilegeDEV() || hasPrivilegeSGM() || hasPrivilegeGM() )
2436 #endif
2437 {
2438 ShowHelp = !ShowHelp;
2439 }
2440 }
2441 };
2442 REGISTER_ACTION_HANDLER (CAHToggleHelp, "toggle_help");
2443
2444 // ***************************************************************************
2445 class CAHSelfTarget : public IActionHandler
2446 {
2447 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
2448 {
2449 // Select the entity
2450 UserEntity->selection(0);
2451 }
2452 };
2453 REGISTER_ACTION_HANDLER (CAHSelfTarget, "self_target");
2454
2455 // ***************************************************************************
2456 class CAHNoTarget : public IActionHandler
2457 {
2458 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
2459 {
2460 // Select the entity
2461 UserEntity->selection(CLFECOMMON::INVALID_SLOT);
2462 }
2463 };
2464 REGISTER_ACTION_HANDLER (CAHNoTarget, "no_target");
2465
2466 // ***************************************************************************
2467 class CAHTarget : public IActionHandler
2468 {
2469 virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
2470 {
2471 string entityName = getParam(Params, "entity");
2472 if (entityName.empty()) return;
2473
2474 string completeMatch = getParam(Params, "prefer_complete_match");
2475 bool quiet = (getParam (Params, "quiet") == "true");
2476
2477 vector<string> keywords;
2478 NLMISC::splitString(entityName, " ", keywords);
2479 if (!keywords.empty() && keywords[0].size() > 0 && keywords[0][0] == '"')
2480 {
2481 // entity name is in quotes, do old style match with 'starts with' filter
2482 // search for optional second parameter from old command for prefer_complete_match param
2483 keywords.clear();
2484
2485 string::size_type lastOf = entityName.rfind("\"");
2486 if (lastOf == 0)
2487 lastOf = string::npos;
2488
2489 // override the value only when there is no 'prefer_complete_match' parameter set
2490 if (completeMatch.empty() && lastOf < entityName.size())
2491 completeMatch = trim(entityName.substr(lastOf+1));
2492
2493 entityName = entityName.substr(1, lastOf-1);
2494 }
2495
2496 // late check because only possible if doing 'starts-with' search
2497 bool preferCompleteMatch = (completeMatch != "0");
2498
2499 CEntityCL *entity = NULL;
2500 if (preferCompleteMatch)
2501 {
2502 // Try to get the entity with complete match first
2503 entity = EntitiesMngr.getEntityByName (entityName, false, true);
2504 }
2505
2506 if (entity == NULL && !keywords.empty())
2507 {
2508 entity = EntitiesMngr.getEntityByKeywords(keywords, true);
2509 }
2510
2511 if (entity == NULL)
2512 {
2513 // Get the entity with a partial match using 'starts with' search
2514 entity = EntitiesMngr.getEntityByName(entityName, false, false);
2515 }
2516
2517 if (entity == NULL)
2518 {
2519 //Get the entity with a sheetName
2520 entity = EntitiesMngr.getEntityBySheetName(entityName);
2521 }
2522
2523 if (entity && entity->properties().selectable() && !entity->getDisplayName().empty())
2524 {
2525 UserEntity->selection(entity->slot());
2526 if (ClientCfg.TargetChangeCompass)
2527 {
2528 CGroupCompas *gc = dynamic_cast<CGroupCompas *>(CWidgetManager::getInstance()->getElementFromId("ui:interface:compass"));
2529 if (gc)
2530 {
2531 CCompassTarget ct;
2532 ct.setType(CCompassTarget::Selection);
2533
2534 gc->setActive(true);
2535 gc->setTarget(ct);
2536 gc->blink();
2537 CWidgetManager::getInstance()->setTopWindow(gc);
2538 }
2539 }
2540 }
2541 else if (!quiet)
2542 {
2543 CInterfaceManager::getInstance()->displaySystemInfo(CI18N::get("uiTargetErrorCmd"));
2544 }
2545 }
2546 };
2547 REGISTER_ACTION_HANDLER (CAHTarget, "target");
2548
2549 // ***************************************************************************
2550 class CAHTargetLandmark : public IActionHandler
2551 {
2552 virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
2553 {
2554 string search = getParam(Params, "search");
2555 if (search.empty()) return;
2556
2557 bool startsWith = false;
2558 if (search.size() > 0 && (search[0] == '\'' || search[0] == '"') && search[0] == search[search.size()-1])
2559 {
2560 startsWith = true;
2561 search = trimQuotes(search);
2562 }
2563
2564 const std::string mapid = "ui:interface:map:content:map_content:actual_map";
2565 CGroupMap* cgMap = dynamic_cast<CGroupMap*>(CWidgetManager::getInstance()->getElementFromId(mapid));
2566 if (cgMap)
2567 {
2568 if (!cgMap->targetLandmarkByName(search, startsWith))
2569 {
2570 CInterfaceManager::getInstance()->displaySystemInfo(CI18N::get("uiTargetErrorCmd"));
2571 }
2572 }
2573 }
2574 };
2575 REGISTER_ACTION_HANDLER (CAHTargetLandmark, "target_landmark");
2576
2577
2578 class CAHAddShape : public IActionHandler
2579 {
2580 virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
2581 {
2582 string sShape = getParam(Params, "shape");
2583
2584 if (sShape.empty())
2585 {
2586 nlwarning("Command 'add_shape': need at least the parameter shape.");
2587 return;
2588 }
2589
2590 if (!Scene)
2591 {
2592 nlwarning("No scene available");
2593 return;
2594 }
2595
2596 if (!UserEntity)
2597 {
2598 nlwarning("UserEntity not yet defined, possibly called runAH from Lua");
2599 return;
2600 }
2601
2602 double x = UserEntity->pos().x;
2603 double y = UserEntity->pos().y;
2604 double z = UserEntity->pos().z;
2605 CVector userDir = UserEntity->dir();
2606 float s = 1.0f;
2607 string skeleton = getParam(Params, "skeleton");
2608 string c = getParam(Params, "text");
2609 string u = getParam(Params, "url");
2610 string texture_name = getParam(Params, "texture");
2611 string highlight = getParam(Params, "highlight");
2612 string transparency = getParam(Params, "transparency");
2613
2614 if (!getParam(Params, "x").empty())
2615 fromString(getParam(Params, "x"), x);
2616 if (!getParam(Params, "y").empty())
2617 fromString(getParam(Params, "y"), y);
2618 if (!getParam(Params, "z").empty())
2619 fromString(getParam(Params, "z"), z);
2620 if (!getParam(Params, "scale").empty())
2621 fromString(getParam(Params, "scale"), s);
2622 if (!getParam(Params, "angle").empty())
2623 {
2624 float a;
2625 fromString(getParam(Params, "angle"), a);
2626 userDir = CVector(sin(a), cos(a), 0.f);
2627 }
2628
2629 bool have_shapes = true;
2630 while(have_shapes)
2631 {
2632 string shape;
2633 string::size_type index = sShape.find(string(" "));
2634 // multiple shapes/fx
2635 if (index != string::npos)
2636 {
2637 shape = sShape.substr(0, index);
2638 sShape = sShape.substr(index+1);
2639 }
2640 else
2641 {
2642 shape = sShape;
2643 have_shapes = false;
2644 }
2645
2646 sint32 idx;
2647 CShapeInstanceReference instref = EntitiesMngr.createInstance(shape, CVector((float)x, (float)y, (float)z), c, u, false, 0, idx);
2648 UInstance instance = instref.Instance;
2649
2650 if(!instance.empty())
2651 {
2652 for(uint j=0;j<instance.getNumMaterials();j++)
2653 {
2654 if (highlight.empty())
2655 {
2656 instance.getMaterial(j).setAmbient(CRGBA(0,0,0,255));
2657 instance.getMaterial(j).setShininess( 10.0f );
2658 instance.getMaterial(j).setEmissive(CRGBA(255,255,255,255));
2659 }
2660 else
2661 {
2662 instance.getMaterial(j).setAmbient(CRGBA(0,0,0,255));
2663 instance.getMaterial(j).setEmissive(CRGBA(255,0,0,255));
2664 instance.getMaterial(j).setShininess( 1000.0f );
2665 }
2666
2667 if (!texture_name.empty())
2668 {
2669 sint numStages = instance.getMaterial(j).getLastTextureStage() + 1;
2670 for(sint l = 0; l < numStages; l++)
2671 {
2672 if (instance.getMaterial(j).isTextureFile((uint) l))
2673 {
2674 instance.getMaterial(j).setTextureFileName(texture_name, (uint) l);
2675 }
2676 }
2677 }
2678 }
2679
2680 if (transparency.empty())
2681 ::makeInstanceTransparent(instance, 255, false);
2682 else
2683 ::makeInstanceTransparent(instance, 100, true);
2684
2685 instance.setClusterSystem(UserEntity->getClusterSystem()); // for simplicity, assume it is in the same
2686 // cluster system than the user
2687 // Compute the direction Matrix
2688 CMatrix dir;
2689 dir.identity();
2690 CVector vi = userDir^CVector(0.f, 0.f, 1.f);
2691 CVector vk = vi^userDir;
2692 dir.setRot(vi, userDir, vk, true);
2693 // Set Orientation : User Direction should be normalized.
2694 if (!skeleton.empty())
2695 {
2696 USkeleton skel = Scene->createSkeleton(skeleton);
2697 if (!skel.empty())
2698 {
2699 skel.bindSkin(instance);
2700 skel.setClusterSystem(UserEntity->getClusterSystem());
2701 skel.setScale(skel.getScale()*s);
2702 skel.setPos(CVector((float)x, (float)y, (float)z));
2703 skel.setRotQuat(dir.getRot());
2704 }
2705 }
2706 else
2707 {
2708 instance.setScale(instance.getScale()*s);
2709 instance.setPos(CVector((float)x, (float)y, (float)z));
2710 instance.setRotQuat(dir.getRot());
2711 }
2712
2713 instance.setTransformMode(UTransformable::RotEuler);
2714
2715 // if the shape is a particle system, additionnal parameters are user params
2716 UParticleSystemInstance psi;
2717 psi.cast (instance);
2718 /*if (!psi.empty())
2719 {
2720 // set each user param that is present
2721 for(uint k = 0; k < 4; ++k)
2722 {
2723 if (args.size() >= (k + 2))
2724 {
2725 float uparam;
2726 if (fromString(args[k + 1], uparam))
2727 {
2728 psi.setUserParam(k, uparam);
2729 }
2730 else
2731 {
2732 nlwarning("Cant read param %d", k);
2733 }
2734 }
2735 }
2736 }*/
2737 }
2738 else
2739 nlwarning("Command 'add_shape': cannot find the shape %s.", sShape.c_str());
2740 }
2741
2742 return;
2743 }
2744 };
2745 REGISTER_ACTION_HANDLER (CAHAddShape, "add_shape");
2746
2747 class CAHRemoveShapes : public IActionHandler
2748 {
2749 virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
2750 {
2751 EntitiesMngr.removeInstances();
2752 }
2753 };
2754 REGISTER_ACTION_HANDLER (CAHRemoveShapes, "remove_shapes");
2755
2756 // ***************************************************************************
2757 // See also CHandlerTeamTarget
2758 class CAHTargetTeammateShortcut : public IActionHandler
2759 {
2760 virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
2761 {
2762 // Get shortcut parameter
2763 uint indexInTeam;
2764 fromString(getParam( Params, "indexInTeam" ), indexInTeam);
2765 --indexInTeam;
2766
2767 if ( indexInTeam >= PeopleInterraction.TeamList.getNumPeople() )
2768 return;
2769
2770 // Index is the database index (serverIndex() not used for team list)
2771 CCDBNodeLeaf *pNL = NLGUI::CDBManager::getInstance()->getDbProp( NLMISC::toString( TEAM_DB_PATH ":%hu:NAME", indexInTeam ), false );
2772 if ( ! pNL )
2773 return;
2774 if ( pNL->getValueBool() )
2775 {
2776 // There is a character corresponding to this index
2777 pNL = NLGUI::CDBManager::getInstance()->getDbProp( NLMISC::toString( TEAM_DB_PATH ":%hu:UID", indexInTeam ), false );
2778 if ( ! pNL )
2779 return;
2780 CLFECOMMON::TClientDataSetIndex compressedIndex = pNL->getValue32();
2781
2782 // Search entity in vision
2783 CEntityCL *entity = EntitiesMngr.getEntityByCompressedIndex( compressedIndex );
2784 if ( entity )
2785 {
2786 UserEntity->selection( entity->slot() );
2787 }
2788 else
2789 {
2790 CInterfaceManager *pIM= CInterfaceManager::getInstance();
2791 pIM->displaySystemInfo(CI18N::get("uiTeamSelectNotInVision"), "CHK");
2792 }
2793 }
2794 }
2795 };
2796 REGISTER_ACTION_HANDLER(CAHTargetTeammateShortcut, "target_teammate_shortcut");
2797
2798 // ***************************************************************************
2799 class CAHAssist : public IActionHandler
2800 {
2801 virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
2802 {
2803 // Get the entity name to target
2804 string entityName = getParam (Params, "entity");
2805 if (!entityName.empty())
2806 {
2807 // Get the entity
2808 CEntityCL *entity = EntitiesMngr.getEntityByName (entityName, false, false);
2809 if (entity)
2810 {
2811 // Select the entity
2812 UserEntity->assist(entity->slot());
2813 }
2814 else
2815 {
2816 CInterfaceManager *pIM= CInterfaceManager::getInstance();
2817 pIM->displaySystemInfo(CI18N::get("uiTargetErrorCmd"));
2818 }
2819 }
2820 }
2821 };
2822 REGISTER_ACTION_HANDLER (CAHAssist, "assist");
2823
2824 // ***************************************************************************
2825 class CAHAssistTarget : public IActionHandler
2826 {
2827 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
2828 {
2829 // Select the entity
2830 UserEntity->assist();
2831 }
2832 };
2833 REGISTER_ACTION_HANDLER (CAHAssistTarget, "assist_target");
2834
2835 // ***************************************************************************
2836 class CAHToggleCombat : public IActionHandler
2837 {
2838 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
2839 {
2840 // Toggle from Combat to Disengage
2841 if(UserEntity->isFighting())
2842 UserEntity->disengage();
2843 // Toggle from Normal to Combat
2844 else
2845 {
2846 if( UserEntity->canEngageCombat() )
2847 {
2848 UserEntity->attack();
2849 }
2850 }
2851
2852 }
2853 };
2854 REGISTER_ACTION_HANDLER (CAHToggleCombat, "toggle_combat");
2855
2856 // ***************************************************************************
2857 class CAHSetDesktop : public IActionHandler
2858 {
2859 public:
2860 CAHSetDesktop()
2861 {
2862 _FirstTime = true;
2863 }
2864
2865 virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
2866 {
2867 CInterfaceManager *pIM = CInterfaceManager::getInstance();
2868 CGroupContainer *pGC = dynamic_cast<CGroupContainer*>(CWidgetManager::getInstance()->getElementFromId("ui:interface:gestion_windows"));
2869 if (pGC == NULL)
2870 {
2871 nlwarning("gestion_windows not found as a container");
2872 return;
2873 }
2874 CInterfaceElement *pIE = CWidgetManager::getInstance()->getElementFromId("ui:interface:gestion_windows:close");
2875 if (pIE != NULL) pIE->setActive(false);
2876
2877 bool switchDesktop = false;
2878
2879 CActionsManager *pAM = &Actions;
2880 if (!pAM->valide(CAction::CName("set_desktop",Params.c_str())))
2881 {
2882 pGC->setActive(false);
2883 _FirstTime = true;
2884 switchDesktop = true;
2885 }
2886 else // Key is down
2887 {
2888 // For the first time ?
2889 if (_FirstTime)
2890 {
2891 _FirstTime = false;
2892 switchDesktop = true;
2893 }
2894 else // Not the first time
2895 {
2896 // Show the container
2897 pGC->setActive(true);
2898 // Yoyo: important to setTopWindow ONLY if needed, else save of the TopWindow doesn't work when you switch it.
2899 CWidgetManager::getInstance()->setTopWindow(pGC);
2900 }
2901 }
2902 if (switchDesktop)
2903 {
2904 vector<string> vecStr;
2905 vecStr.push_back("tb_setdesktop");
2906 vecStr.push_back(Params);
2907 CWidgetManager::getInstance()->runProcedure("tb_setdesktop", NULL, vecStr);
2908 }
2909 }
2910 private:
2911 bool _FirstTime;
2912 };
2913 REGISTER_ACTION_HANDLER (CAHSetDesktop, "set_desktop");
2914
2915 // ***************************************************************************
2916 class CAHCopyToDesktop : public IActionHandler
2917 {
2918 public:
2919
2920 virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
2921 {
2922 CInterfaceManager *pIM = CInterfaceManager::getInstance();
2923 uint8 newMode;
2924 fromString(Params, newMode);
2925 pIM->resetMode(newMode);
2926 uint8 nLastMode = pIM->getMode();
2927 pIM->setMode(newMode);
2928 pIM->setMode(nLastMode);
2929 }
2930 };
2931 REGISTER_ACTION_HANDLER (CAHCopyToDesktop, "copy_to_desktop");
2932
2933
2934 // ***************************************************************************
2935 class CHandlerCloseAllLabosBut : public IActionHandler
2936 {
2937 virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
2938 {
2939 CInterfaceManager *pIM= CInterfaceManager::getInstance();
2940
2941 // list of labo windows
2942 const char* laboWindows[]= {
2943 "ui:interface:faber_create",
2944 "ui:interface:faber_repair",
2945 "ui:interface:faber_refine",
2946 "ui:interface:combat",
2947 "ui:interface:magic",
2948 "ui:interface:special_labo",
2949 "ui:interface:commerce",
2950 "ui:interface:tracking",
2951 };
2952 uint numLabos= sizeof(laboWindows)/sizeof(laboWindows[0]);
2953
2954 // For all labos
2955 for(uint i=0;i<numLabos;i++)
2956 {
2957 // if not the excluded one
2958 if( Params != laboWindows[i] )
2959 {
2960 CInterfaceElement *pElt= CWidgetManager::getInstance()->getElementFromId(laboWindows[i]);
2961 if(pElt)
2962 pElt->setActive(false);
2963 }
2964 }
2965 }
2966 };
2967 REGISTER_ACTION_HANDLER (CHandlerCloseAllLabosBut, "close_all_labos_but");
2968
2969 /*
2970 // ***************************************************************************
2971 class CHandlerToggleInventory : public IActionHandler
2972 {
2973 virtual void execute (CCtrlBase *pCaller, const string &Params)
2974 {
2975 CInterfaceManager *pIM= CInterfaceManager::getInstance();
2976
2977 // list of labo windows
2978 const char* inventoryWindows[]= {
2979 "ui:interface:gestionsets",
2980 "ui:interface:userbags",
2981 "ui:interface:usermoney",
2982 "ui:interface:userarmors",
2983 "ui:interface:userjewelry",
2984 };
2985 uint numWins= sizeof(inventoryWindows)/sizeof(inventoryWindows[0]);
2986
2987 // For all labos
2988 bool state = false;
2989 CInterfaceElement *pElt= CWidgetManager::getInstance()->getElementFromId(inventoryWindows[0]);
2990 if (pElt)
2991 state = !pElt->getActive();
2992 for(uint i=0;i<numWins;i++)
2993 {
2994 pElt= CWidgetManager::getInstance()->getElementFromId(inventoryWindows[i]);
2995 if(pElt)
2996 pElt->setActive(state);
2997 }
2998 }
2999 };
3000 REGISTER_ACTION_HANDLER (CHandlerToggleInventory, "toggle_inventory");
3001 */
3002 // ***************************************************************************
3003 // ***************************************************************************
3004 // GAME CONFIG
3005 // ***************************************************************************
3006 // ***************************************************************************
3007
3008 #define GAME_CONFIG_DDX "ui:interface:game_config:content:all"
3009 #define GAME_CONFIG_TREE_LIST "ui:interface:game_config:content:sbtree:tree_list"
3010
3011 static vector<UDriver::CMode> VideoModes;
3012 #define GAME_CONFIG_VIDEO_MODES_COMBO "ui:interface:game_config:content:general:video_modes"
3013 #define GAME_CONFIG_VIDEO_FREQS_COMBO "ui:interface:game_config:content:general:video_freqs"
3014 #define GAME_CONFIG_VIDEO_FULLSCREEN_BUTTON "ui:interface:game_config:content:general:fullscreen:c"
3015 #define GAME_CONFIG_VIDEO_MODE_DB "UI:TEMP:VID_MODE"
3016 #define GAME_CONFIG_VIDEO_FREQ_DB "UI:TEMP:VID_FREQ"
3017 #define GAME_CONFIG_LANGUAGE "UI:TEMP:LANGUAGE"
3018 // We allow only this RGB depth to be taken
3019 #define GAME_CONFIG_VIDEO_DEPTH_REQ 32
3020
3021 // VR_CONFIG
3022 #define GAME_CONFIG_VR_ENABLE_BUTTON "ui:interface:game_config:content:vr:enabler:c"
3023 #define GAME_CONFIG_VR_DEVICES_COMBO "ui:interface:game_config:content:vr:vr_devices"
3024 #define GAME_CONFIG_VR_DEVICE_DB "UI:TEMP:VR_DEVICE"
3025
3026 // The combo for Texture Mode selected
3027 #define GAME_CONFIG_TEXTURE_MODE_COMBO "ui:interface:game_config:content:general:texture_mode:combo"
3028 #define GAME_CONFIG_TEXTURE_MODE_DB "UI:TEMP:TEXTURE_MODE"
3029
3030 // Anisotropic Filtering controls
3031 #define GAME_CONFIG_ANISOTROPIC_COMBO "ui:interface:game_config:content:fx:anisotropic_gr:anisotropic"
3032 #define GAME_CONFIG_ANISOTROPIC_DB "UI:TEMP:ANISOTROPIC"
3033
3034 // The 3 possible modes editable (NB: do not allow client.cfg HDEntityTexture==1 and DivideTextureSizeBy2=2
3035 enum TTextureMode {LowTextureMode= 0, NormalTextureMode= 1, HighTextureMode= 2};
3036
3037 void cacheStereoDisplayDevices(); // from init.cpp
3038
3039 void updateVRDevicesComboUI(bool enable)
3040 {
3041 // VR_CONFIG
3042 nldebug("Init VR device name list from cache into UI");
3043 // init vr device name list from cache
3044 CDBGroupComboBox *pCB = dynamic_cast<CDBGroupComboBox*>(CWidgetManager::getInstance()->getElementFromId(GAME_CONFIG_VR_DEVICES_COMBO));
3045 if (pCB)
3046 {
3047 pCB->setActive(enable);
3048 if (enable)
3049 {
3050 nldebug("pCB ok");
3051 cacheStereoDisplayDevices();
3052 pCB->resetTexts();
3053 sint32 selectedDevice = -1;
3054 for (uint i = 0; i < VRDeviceCache.size(); ++i)
3055 {
3056 std::stringstream displayname;
3057 displayname << std::string("[") << VRDeviceCache[i].first << "] [" << VRDeviceCache[i].second << "]";
3058 pCB->addText(displayname.str());
3059 if (ClientCfg.VRDisplayDevice == VRDeviceCache[i].first)
3060 {
3061 if (selectedDevice == -1 || ClientCfg.VRDisplayDeviceId == VRDeviceCache[i].second)
3062 {
3063 selectedDevice = i;
3064 }
3065 }
3066 }
3067 if (selectedDevice == -1)
3068 {
3069 // configured device not found, add a dummy
3070 std::stringstream displayname;
3071 displayname << std::string("[") << ClientCfg.VRDisplayDevice << "] [" << ClientCfg.VRDisplayDeviceId<< "] [DEVICE NOT FOUND]";
3072 pCB->addText(displayname.str());
3073 selectedDevice = VRDeviceCache.size();
3074 }
3075 NLGUI::CDBManager::getInstance()->getDbProp(GAME_CONFIG_VR_DEVICE_DB)->setValue32(-1);
3076 NLGUI::CDBManager::getInstance()->getDbProp(GAME_CONFIG_VR_DEVICE_DB)->setValue32(selectedDevice);
3077 }
3078 }
3079 }
3080
3081 // ***************************************************************************
3082 class CHandlerGameConfigInit : public IActionHandler
3083 {
3084 public:
3085 // Value used to restore the screen AR in case of a cancel
3086 static float BkupScreenAspectRatio;
3087
3088 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
3089 {
3090 if (Driver == NULL) return;
3091
3092 VideoModes.clear();
3093 vector<string> stringModeList, stringFreqList;
3094 sint nFoundMode, nFoundFreq;
3095
3096 getRyzomModes(VideoModes, stringModeList, stringFreqList, nFoundMode, nFoundFreq);
3097
3098 // Initialize interface combo box
3099 CInterfaceManager *pIM = CInterfaceManager::getInstance();
3100
3101 // resolutions
3102 CDBGroupComboBox *pCB= dynamic_cast<CDBGroupComboBox*>(CWidgetManager::getInstance()->getElementFromId( GAME_CONFIG_VIDEO_MODES_COMBO ));
3103 if( pCB )
3104 {
3105 pCB->resetTexts();
3106 for (sint j = 0; j < (sint)stringModeList.size(); j++)
3107 pCB->addText(stringModeList[j]);
3108 }
3109
3110 // frequencies
3111 pCB= dynamic_cast<CDBGroupComboBox*>(CWidgetManager::getInstance()->getElementFromId( GAME_CONFIG_VIDEO_FREQS_COMBO ));
3112 if( pCB )
3113 {
3114 pCB->resetTexts();
3115 for (sint j = 0; j < (sint)stringFreqList.size(); j++)
3116 pCB->addText(stringFreqList[j]);
3117 }
3118
3119 // -1 is important to indicate we set this value in edit mode
3120 NLGUI::CDBManager::getInstance()->getDbProp( GAME_CONFIG_VIDEO_MODE_DB )->setValue32(-1);
3121 NLGUI::CDBManager::getInstance()->getDbProp( GAME_CONFIG_VIDEO_MODE_DB )->setValue32(nFoundMode);
3122
3123 NLGUI::CDBManager::getInstance()->getDbProp( GAME_CONFIG_VIDEO_FREQ_DB )->setValue32(-1);
3124 NLGUI::CDBManager::getInstance()->getDbProp( GAME_CONFIG_VIDEO_FREQ_DB )->setValue32(nFoundFreq);
3125
3126 CCtrlBaseButton *pBut = dynamic_cast<CCtrlBaseButton*>(CWidgetManager::getInstance()->getElementFromId( GAME_CONFIG_VIDEO_FULLSCREEN_BUTTON ));
3127 if (pBut)
3128 {
3129 pBut->setPushed(!ClientCfg.Windowed);
3130 }
3131 CAHManager::getInstance()->runActionHandler("game_config_change_vid_fullscreen",NULL);
3132
3133 // **** Init Texture Size Modes
3134 // init the combo box, according to Texture Installed or not
3135 pCB = dynamic_cast<CDBGroupComboBox*>(CWidgetManager::getInstance()->getElementFromId( GAME_CONFIG_TEXTURE_MODE_COMBO ));
3136 if( pCB )
3137 {
3138 pCB->resetTexts();
3139 pCB->addText(CI18N::get("uigcLowTextureMode"));
3140 pCB->addText(CI18N::get("uigcNormalTextureMode"));
3141 if(ClientCfg.HDTextureInstalled)
3142 pCB->addText(CI18N::get("uigcHighTextureMode"));
3143 }
3144
3145 // Anisotropic Filtering
3146 pCB = dynamic_cast<CDBGroupComboBox*>(CWidgetManager::getInstance()->getElementFromId(GAME_CONFIG_ANISOTROPIC_COMBO));
3147
3148 sint nAnisotropic = 0;
3149
3150 if (pCB)
3151 {
3152 sint maxAnisotropic = (sint)Driver->getAnisotropicFilterMaximum();
3153
3154 pCB->resetTexts();
3155 pCB->addText(CI18N::get("uigcFxAnisotropicFilterNone"));
3156
3157 sint anisotropic = 2;
3158 uint i = 1;
3159
3160 while (anisotropic <= maxAnisotropic)
3161 {
3162 pCB->addText(NLMISC::toString("%dx", anisotropic));
3163
3164 if (ClientCfg.AnisotropicFilter == anisotropic)
3165 nAnisotropic = i;
3166
3167 anisotropic <<= 1;
3168 ++i;
3169 }
3170 }
3171
3172 // -1 is important to indicate we set this value in edit mode
3173 NLGUI::CDBManager::getInstance()->getDbProp( GAME_CONFIG_ANISOTROPIC_DB )->setValue32(-1);
3174 NLGUI::CDBManager::getInstance()->getDbProp( GAME_CONFIG_ANISOTROPIC_DB )->setValue32(nAnisotropic);
3175
3176 // VR_CONFIG
3177 pBut = dynamic_cast<CCtrlBaseButton*>(CWidgetManager::getInstance()->getElementFromId(GAME_CONFIG_VR_ENABLE_BUTTON));
3178 if (pBut)
3179 {
3180 pBut->setPushed(ClientCfg.VREnable);
3181 }
3182
3183 updateVRDevicesComboUI(ClientCfg.VREnable);
3184
3185 // init the mode in DB
3186 TTextureMode texMode;
3187 if(ClientCfg.DivideTextureSizeBy2)
3188 texMode= LowTextureMode;
3189 else if(ClientCfg.HDEntityTexture && ClientCfg.HDTextureInstalled)
3190 texMode= HighTextureMode;
3191 else
3192 texMode= NormalTextureMode;
3193
3194 // -1 is important to indicate we set this value in edit mode
3195 NLGUI::CDBManager::getInstance()->getDbProp( GAME_CONFIG_TEXTURE_MODE_DB )->setValue32(-1);
3196 NLGUI::CDBManager::getInstance()->getDbProp( GAME_CONFIG_TEXTURE_MODE_DB )->setValue32(texMode);
3197
3198 // **** Init Screen Aspect Ratio
3199 // Init the combo box, according to the value
3200 pCB= dynamic_cast<CDBGroupComboBox*>( CWidgetManager::getInstance()->getElementFromDefine( "game_config_screen_ratio_cb" ));
3201 if(pCB)
3202 {
3203 // Bkup for cancel
3204 BkupScreenAspectRatio= ClientCfg.ScreenAspectRatio;
3205
3206 // -1 is here to force var change
3207 NLGUI::CDBManager::getInstance()->getDbProp( "UI:TEMP:SCREEN_RATIO_MODE" )->setValue32(-1);
3208
3209 // detect with an epsilon to avoid float precision problems
3210 if(fabs(ClientCfg.ScreenAspectRatio - 1.33333f)<=0.00001f)
3211 NLGUI::CDBManager::getInstance()->getDbProp( "UI:TEMP:SCREEN_RATIO_MODE" )->setValue32(0); // 4/3
3212 else if(fabs(ClientCfg.ScreenAspectRatio - 1.77777f)<=0.00001f)
3213 NLGUI::CDBManager::getInstance()->getDbProp( "UI:TEMP:SCREEN_RATIO_MODE" )->setValue32(1); // 16/9
3214 else if(ClientCfg.ScreenAspectRatio == 0.f)
3215 NLGUI::CDBManager::getInstance()->getDbProp( "UI:TEMP:SCREEN_RATIO_MODE" )->setValue32(3); // Auto
3216 else
3217 NLGUI::CDBManager::getInstance()->getDbProp( "UI:TEMP:SCREEN_RATIO_MODE" )->setValue32(2); // Custom
3218 }
3219
3220 // **** Init Language : look in game_config.lua
3221
3222 // display or not VR page
3223 NLGUI::CGroupTree* configTree = dynamic_cast<CGroupTree*>(CWidgetManager::getInstance()->getElementFromId(GAME_CONFIG_TREE_LIST));
3224
3225 if (configTree)
3226 {
3227 CGroupTree::SNode *rootNode = configTree->getRootNode();
3228
3229 if (rootNode)
3230 {
3231 CGroupTree::SNode *graphNode = rootNode->getNodeFromId("graph");
3232
3233 if (graphNode)
3234 {
3235 CGroupTree::SNode *vrNode = graphNode->getNodeFromId("vr");
3236
3237 if (vrNode)
3238 {
3239 vrNode->setShow(isStereoAvailable());
3240 }
3241 }
3242 }
3243 }
3244 }
3245 };
3246 REGISTER_ACTION_HANDLER (CHandlerGameConfigInit, "game_config_init");
3247 float CHandlerGameConfigInit::BkupScreenAspectRatio= 1.3333f;
3248
3249
3250 // ***************************************************************************
3251 class CHandlerGameConfigMode : public IActionHandler
3252 {
3253 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
3254 {
3255 CInterfaceManager *pIM = CInterfaceManager::getInstance();
3256
3257 sint oldVideoMode= NLGUI::CDBManager::getInstance()->getDbProp( GAME_CONFIG_VIDEO_MODE_DB )->getOldValue32();
3258 sint nVideModeNb = NLGUI::CDBManager::getInstance()->getDbProp( GAME_CONFIG_VIDEO_MODE_DB )->getValue32();
3259 if (nVideModeNb == -1 || oldVideoMode == -1) return;
3260
3261 CDBGroupComboBox *pCB= dynamic_cast<CDBGroupComboBox*>(CWidgetManager::getInstance()->getElementFromId( GAME_CONFIG_VIDEO_MODES_COMBO ));
3262 if( pCB == NULL ) return;
3263
3264 // Get W, H
3265 sint w,h;
3266 {
3267 string vidModeStr = pCB->getText(nVideModeNb);
3268 string tmp = vidModeStr.substr(0,vidModeStr.find('x')-1);
3269 fromString(tmp, w);
3270 tmp = vidModeStr.substr(vidModeStr.find('x')+2,vidModeStr.size());
3271 fromString(tmp, h);
3272 }
3273
3274 // Filter VideoModes list to get freqs
3275 vector<string> stringFreqList;
3276 sint i, j, nFoundFreq = -1;
3277 for (i=0; i < (sint)VideoModes.size(); ++i)
3278 {
3279 if ((VideoModes[i].Width == w) && (VideoModes[i].Height == h) && (VideoModes[i].Depth == GAME_CONFIG_VIDEO_DEPTH_REQ))
3280 {
3281 bool bFound = false;
3282 string tmp = toString(VideoModes[i].Frequency);
3283 for (j = 0; j < (sint)stringFreqList.size(); ++j)
3284 {
3285 if (stringFreqList[j] == tmp)
3286 {
3287 bFound = true;
3288 break;
3289 }
3290 }
3291
3292 if (!bFound)
3293 {
3294 stringFreqList.push_back(tmp);
3295 if (ClientCfg.Frequency == VideoModes[i].Frequency)
3296 nFoundFreq = j;
3297 }
3298 }
3299 }
3300 if (nFoundFreq == -1) nFoundFreq = 0;
3301 // Initialize interface combo box
3302 pCB= dynamic_cast<CDBGroupComboBox*>(CWidgetManager::getInstance()->getElementFromId( GAME_CONFIG_VIDEO_FREQS_COMBO ));
3303 if( pCB )
3304 {
3305 pCB->resetTexts();
3306 for (j = 0; j < (sint)stringFreqList.size(); j++)
3307 pCB->addText(stringFreqList[j] + " Hz");
3308 }
3309 NLGUI::CDBManager::getInstance()->getDbProp( GAME_CONFIG_VIDEO_FREQ_DB )->setValue32(nFoundFreq);
3310
3311 // **** dirt the apply button of the DDX
3312 // don't do it at init!
3313 if(oldVideoMode!=-1 && nVideModeNb!=-1)
3314 {
3315 CDDXManager *pDM = CDDXManager::getInstance();
3316 CInterfaceDDX *pDDX = pDM->get(GAME_CONFIG_DDX);
3317 if(pDDX)
3318 pDDX->validateApplyButton();
3319 }
3320 }
3321 };
3322 REGISTER_ACTION_HANDLER (CHandlerGameConfigMode, "game_config_change_vid_mode");
3323
3324 // ***************************************************************************
3325 class CHandlerGameConfigLanguage : public IActionHandler
3326 {
3327 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
3328 {
3329 CInterfaceManager *pIM = CInterfaceManager::getInstance();
3330
3331 sint old = NLGUI::CDBManager::getInstance()->getDbProp( GAME_CONFIG_LANGUAGE )->getOldValue32();
3332 sint newOne = NLGUI::CDBManager::getInstance()->getDbProp( GAME_CONFIG_LANGUAGE )->getValue32();
3333 if ((old != -1) && (newOne != -1))
3334 {
3335 // Set the new language
3336 //string newVal = (newOne==2)?"de":(newOne==1)?"fr":"en";
3337 string newVal = convertLanguageIntToLanguageCode(newOne);
3338 if (ClientCfg.LanguageCode != newVal)
3339 {
3340 CDDXManager *pDM = CDDXManager::getInstance();
3341 CInterfaceDDX *pDDX = pDM->get(GAME_CONFIG_DDX);
3342 if(pDDX)
3343 pDDX->validateApplyButton();
3344 }
3345 }
3346 }
3347 };
3348 REGISTER_ACTION_HANDLER (CHandlerGameConfigLanguage, "game_config_change_language");
3349
3350 // ***************************************************************************
3351 class CHandlerGameConfigFreq : public IActionHandler
3352 {
3353 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
3354 {
3355 CInterfaceManager *pIM= CInterfaceManager::getInstance();
3356 sint oldFreq= NLGUI::CDBManager::getInstance()->getDbProp( GAME_CONFIG_VIDEO_FREQ_DB )->getOldValue32();
3357 sint newFreq= NLGUI::CDBManager::getInstance()->getDbProp( GAME_CONFIG_VIDEO_FREQ_DB )->getValue32();
3358
3359 // dirt the apply button of the DDX.
3360 // don't do it at init!
3361 if(oldFreq!=-1 && newFreq!=-1)
3362 {
3363 CDDXManager *pDM = CDDXManager::getInstance();
3364 CInterfaceDDX *pDDX = pDM->get(GAME_CONFIG_DDX);
3365 if(pDDX)
3366 pDDX->validateApplyButton();
3367 }
3368 }
3369 };
3370 REGISTER_ACTION_HANDLER (CHandlerGameConfigFreq, "game_config_change_vid_freq");
3371
3372 // ***************************************************************************
3373 class CHandlerGameConfigTextureMode : public IActionHandler
3374 {
3375 public:
3376 virtual void execute(CCtrlBase * /* pCalller */, const string &/* Params */)
3377 {
3378 CInterfaceManager *pIM= CInterfaceManager::getInstance();
3379 sint oldTMode= NLGUI::CDBManager::getInstance()->getDbProp( GAME_CONFIG_TEXTURE_MODE_DB )->getOldValue32();
3380 sint newTMode= NLGUI::CDBManager::getInstance()->getDbProp( GAME_CONFIG_TEXTURE_MODE_DB )->getValue32();
3381
3382 // dirt the apply button of the DDX
3383 // don't do it at init!
3384 if(oldTMode!=-1 && newTMode!=-1)
3385 {
3386 CDDXManager *pDM = CDDXManager::getInstance();
3387 CInterfaceDDX *pDDX = pDM->get(GAME_CONFIG_DDX);
3388 if(pDDX)
3389 pDDX->validateApplyButton();
3390 }
3391 }
3392 };
3393 REGISTER_ACTION_HANDLER (CHandlerGameConfigTextureMode, "game_config_change_texture_mode");
3394
3395 // ***************************************************************************
3396 class CHandlerGameConfigFullscreen : public IActionHandler
3397 {
3398 virtual void execute (CCtrlBase *pCaller, const string &/* Params */)
3399 {
3400 CInterfaceManager *pIM = CInterfaceManager::getInstance();
3401 bool bFullscreen = false;
3402 {
3403 CCtrlBaseButton *pBut = dynamic_cast<CCtrlBaseButton*>(CWidgetManager::getInstance()->getElementFromId( GAME_CONFIG_VIDEO_FULLSCREEN_BUTTON ));
3404 if (pBut) bFullscreen = pBut->getPushed();
3405 }
3406 CDBGroupComboBox *pCB;
3407 if (bFullscreen)
3408 {
3409 // show modes combo
3410 pCB= dynamic_cast<CDBGroupComboBox*>(CWidgetManager::getInstance()->getElementFromId( GAME_CONFIG_VIDEO_MODES_COMBO ));
3411 if (pCB) pCB->setActive(true);
3412
3413 // show frequencies combo
3414 pCB= dynamic_cast<CDBGroupComboBox*>(CWidgetManager::getInstance()->getElementFromId( GAME_CONFIG_VIDEO_FREQS_COMBO ));
3415 if (pCB) pCB->setActive(true);
3416 }
3417 else
3418 {
3419 // hide modes combo
3420 pCB= dynamic_cast<CDBGroupComboBox*>(CWidgetManager::getInstance()->getElementFromId( GAME_CONFIG_VIDEO_MODES_COMBO ));
3421 if (pCB) pCB->setActive(false);
3422
3423 // hide frequencies combo
3424 pCB= dynamic_cast<CDBGroupComboBox*>(CWidgetManager::getInstance()->getElementFromId( GAME_CONFIG_VIDEO_FREQS_COMBO ));
3425 if (pCB) pCB->setActive(false);
3426 }
3427
3428 // **** dirt the apply button of the DDX
3429 // if caller is NULL, come from init, so don't validate the apply button
3430 if(pCaller)
3431 {
3432 CDDXManager *pDM = CDDXManager::getInstance();
3433 CInterfaceDDX *pDDX = pDM->get(GAME_CONFIG_DDX);
3434 if(pDDX)
3435 pDDX->validateApplyButton();
3436 }
3437 }
3438 };
3439 REGISTER_ACTION_HANDLER (CHandlerGameConfigFullscreen, "game_config_change_vid_fullscreen");
3440
3441 // ***************************************************************************
3442 class CHandlerGameConfigVREnable : public IActionHandler
3443 {
3444 virtual void execute (CCtrlBase *pCaller, const string &/* Params */)
3445 {
3446 // VR_CONFIG
3447
3448 CCtrlBaseButton *pBut = dynamic_cast<CCtrlBaseButton*>(CWidgetManager::getInstance()->getElementFromId(GAME_CONFIG_VR_ENABLE_BUTTON));
3449 if (pBut)
3450 {
3451 // hide or show device list depending on enabled or not
3452 updateVRDevicesComboUI(pBut->getPushed());
3453 }
3454
3455 if (pCaller)
3456 {
3457 CDDXManager *pDM = CDDXManager::getInstance();
3458 CInterfaceDDX *pDDX = pDM->get(GAME_CONFIG_DDX);
3459 if(pDDX)
3460 pDDX->validateApplyButton();
3461 }
3462 }
3463 };
3464 REGISTER_ACTION_HANDLER (CHandlerGameConfigVREnable, "game_config_change_vr_enable");
3465
3466 // ***************************************************************************
3467 class CHandlerGameConfigVRDevice : public IActionHandler
3468 {
3469 virtual void execute (CCtrlBase *pCaller, const string &/* Params */)
3470 {
3471 // VR_CONFIG
3472
3473 sint oldDevice = NLGUI::CDBManager::getInstance()->getDbProp(GAME_CONFIG_VR_DEVICE_DB)->getOldValue32();
3474 sint newDevice = NLGUI::CDBManager::getInstance()->getDbProp(GAME_CONFIG_VR_DEVICE_DB)->getValue32();
3475
3476 if (oldDevice != -1 && newDevice != -1 && pCaller)
3477 {
3478 // nldebug("TODO_VR switch vr device (from combo box)");
3479
3480 CDDXManager *pDM = CDDXManager::getInstance();
3481 CInterfaceDDX *pDDX = pDM->get(GAME_CONFIG_DDX);
3482 if(pDDX)
3483 pDDX->validateApplyButton();
3484 }
3485 }
3486 };
3487 REGISTER_ACTION_HANDLER (CHandlerGameConfigVRDevice, "game_config_change_vr_device");
3488
3489 // ***************************************************************************
3490 class CHandlerGameConfigApply : public IActionHandler
3491 {
3492 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
3493 {
3494 CInterfaceManager *pIM = CInterfaceManager::getInstance();
3495
3496 // **** Apply the video mode
3497 sint nVideModeNb = NLGUI::CDBManager::getInstance()->getDbProp( GAME_CONFIG_VIDEO_MODE_DB )->getValue32();
3498 if (nVideModeNb != -1)
3499 {
3500 sint nVideoFreqNb = NLGUI::CDBManager::getInstance()->getDbProp( GAME_CONFIG_VIDEO_FREQ_DB )->getValue32();
3501 if (nVideoFreqNb != -1)
3502 {
3503 // Get W, H
3504 sint w = 1024, h = 768;
3505 string name;
3506 {
3507 CDBGroupComboBox *pCB = dynamic_cast<CDBGroupComboBox*>(CWidgetManager::getInstance()->getElementFromId( GAME_CONFIG_VIDEO_MODES_COMBO ));
3508 if( pCB != NULL )
3509 {
3510 string vidModeStr = pCB->getText(nVideModeNb);
3511 string tmp = vidModeStr.substr(0,vidModeStr.find('x')-1);
3512 fromString(tmp, w);
3513 tmp = vidModeStr.substr(vidModeStr.find('x')+2,vidModeStr.size());
3514 fromString(tmp, h);
3515
3516 // extract monitor "1024x768 (VGA-1)"
3517 string::size_type pos = vidModeStr.find('(');
3518 if (pos != std::string::npos)
3519 name = vidModeStr.substr(pos + 1, vidModeStr.find(")") - pos - 1);
3520 }
3521 }
3522
3523 // Get Frequency
3524 sint freq = 60;
3525 {
3526 CDBGroupComboBox *pCB = dynamic_cast<CDBGroupComboBox*>(CWidgetManager::getInstance()->getElementFromId( GAME_CONFIG_VIDEO_FREQS_COMBO ));
3527 if( pCB != NULL )
3528 {
3529 string vidFreqStr = pCB->getText(nVideoFreqNb);
3530 fromString(vidFreqStr, freq);
3531 }
3532 }
3533
3534 // Get Fullscreen
3535 bool bFullscreen = false;
3536 {
3537 CCtrlBaseButton *pBut = dynamic_cast<CCtrlBaseButton*>(CWidgetManager::getInstance()->getElementFromId( GAME_CONFIG_VIDEO_FULLSCREEN_BUTTON ));
3538 if (pBut != NULL)
3539 bFullscreen = pBut->getPushed();
3540 }
3541
3542 ClientCfg.Windowed = !bFullscreen;
3543
3544 UDriver::CMode screenMode;
3545 Driver->getCurrentScreenMode(screenMode);
3546
3547 if (bFullscreen)
3548 {
3549 ClientCfg.Depth = screenMode.Depth;
3550 ClientCfg.Frequency = freq;
3551 }
3552 else
3553 {
3554 uint32 width, height;
3555 Driver->getWindowSize(width, height);
3556 w = width;
3557 h = height;
3558 }
3559
3560 ClientCfg.Width = w;
3561 ClientCfg.Height = h;
3562 ClientCfg.MonitorName = name;
3563
3564 // Write the modified client.cfg
3565 ClientCfg.writeBool("FullScreen", bFullscreen);
3566 ClientCfg.writeInt("Width", w);
3567 ClientCfg.writeInt("Height", h);
3568
3569 if (bFullscreen)
3570 {
3571 ClientCfg.writeString("MonitorName", name, true);
3572 ClientCfg.writeInt("Depth", screenMode.Depth);
3573 ClientCfg.writeInt("Frequency", freq);
3574 }
3575 }
3576 }
3577
3578 // save user created channels options
3579 CCtrlBaseButton *pCS = dynamic_cast<CCtrlBaseButton*>(CWidgetManager::getInstance()->getElementFromDefine("game_config_save_channel_cb"));
3580 if (pCS)
3581 NLGUI::CDBManager::getInstance()->getDbProp("UI:SAVE:CHAT:SAVE_CHANNEL")->setValue32(pCS->getPushed());
3582
3583 pCS = dynamic_cast<CCtrlBaseButton*>(CWidgetManager::getInstance()->getElementFromDefine("game_config_auto_channel_cb"));
3584 if (pCS)
3585 NLGUI::CDBManager::getInstance()->getDbProp("UI:SAVE:CHAT:AUTO_CHANNEL")->setValue32(pCS->getPushed());
3586
3587 CCtrlBaseButton *pBut = dynamic_cast<CCtrlBaseButton*>(CWidgetManager::getInstance()->getElementFromId(GAME_CONFIG_VR_ENABLE_BUTTON));
3588 if (pBut)
3589 {
3590 // store the new config variables
3591 ClientCfg.VREnable = pBut->getPushed();
3592 ClientCfg.writeBool("VREnable", pBut->getPushed());
3593 }
3594 if (ClientCfg.VREnable)
3595 {
3596 // store the new config variables
3597 sint deviceIdx = NLGUI::CDBManager::getInstance()->getDbProp(GAME_CONFIG_VR_DEVICE_DB)->getValue32();
3598 ClientCfg.VRDisplayDevice = VRDeviceCache[deviceIdx].first;
3599 ClientCfg.VRDisplayDeviceId = VRDeviceCache[deviceIdx].second;
3600 ClientCfg.writeString("VRDisplayDevice", VRDeviceCache[deviceIdx].first);
3601 ClientCfg.writeString("VRDisplayDeviceId", VRDeviceCache[deviceIdx].second);
3602 }
3603
3604 bool requestReboot = false;
3605
3606 // **** Apply the texture mode
3607 sint nTexMode = NLGUI::CDBManager::getInstance()->getDbProp( GAME_CONFIG_TEXTURE_MODE_DB )->getValue32();
3608 if (nTexMode>=0 && nTexMode<=HighTextureMode)
3609 {
3610 if ((ClientCfg.DivideTextureSizeBy2 != (nTexMode==LowTextureMode)) ||
3611 (ClientCfg.HDEntityTexture != (nTexMode==HighTextureMode)))
3612 {
3613 ClientCfg.DivideTextureSizeBy2= nTexMode==LowTextureMode;
3614 ClientCfg.HDEntityTexture= nTexMode==HighTextureMode;
3615 ClientCfg.writeInt("DivideTextureSizeBy2", ClientCfg.DivideTextureSizeBy2);
3616 ClientCfg.writeInt("HDEntityTexture", ClientCfg.HDEntityTexture);
3617 requestReboot = true;
3618 }
3619 }
3620
3621 // **** Apply Anisotropic Filtering
3622 // read value from DB, it's a combo so value is the index of text
3623 sint nAnisotropic = NLGUI::CDBManager::getInstance()->getDbProp( GAME_CONFIG_ANISOTROPIC_DB )->getValue32();
3624
3625 if (nAnisotropic >= 0)
3626 {
3627 sint anisotropic = 0;
3628
3629 // compute the real anisotropic value
3630 if (nAnisotropic > 0)
3631 {
3632 anisotropic = 2;
3633
3634 for(sint i = 1; i < nAnisotropic; ++i)
3635 {
3636 anisotropic <<= 1;
3637 }
3638 }
3639
3640 if (ClientCfg.AnisotropicFilter != anisotropic)
3641 {
3642 ClientCfg.AnisotropicFilter = anisotropic;
3643 ClientCfg.writeInt("AnisotropicFilter", ClientCfg.AnisotropicFilter);
3644 requestReboot = true;
3645 }
3646 }
3647
3648 // *** Apply the Screen AR
3649 // since already set in the config file, need only to bkup the current version
3650 CHandlerGameConfigInit::BkupScreenAspectRatio= ClientCfg.ScreenAspectRatio;
3651
3652 // *** Apply the language code
3653 // only if not in "work" language mode (else strange requestReboot)
3654 if (ClientCfg.LanguageCode!="wk")
3655 {
3656 sint newOne = NLGUI::CDBManager::getInstance()->getDbProp( GAME_CONFIG_LANGUAGE )->getValue32();
3657 //string newVal = (newOne==2)?"de":(newOne==1)?"fr":"en";
3658 string newVal = convertLanguageIntToLanguageCode(newOne);
3659 if (ClientCfg.LanguageCode != newVal)
3660 {
3661 ClientCfg.LanguageCode = newVal;
3662 ClientCfg.writeString("LanguageCode", ClientCfg.LanguageCode);
3663 requestReboot = true;
3664 }
3665 }
3666
3667 // Apply the NPC icon display mode
3668 CNPCIconCache::getInstance().setEnabled(!ClientCfg.R2EDEnabled && NLGUI::CDBManager::getInstance()->getDbProp("UI:SAVE:INSCENE:FRIEND:MISSION_ICON")->getValueBool());
3669
3670 // Request a reboot
3671 if (requestReboot)
3672 pIM->messageBox (CI18N::get ("uigcRequestReboot"));
3673
3674 // **** Save the config
3675 if (ClientCfg.SaveConfig)
3676 ClientCfg.ConfigFile.save ();
3677 ClientCfg.IsInvalidated = true;
3678 }
3679 };
3680 REGISTER_ACTION_HANDLER (CHandlerGameConfigApply, "game_config_apply");
3681
3682
3683 // ***************************************************************************
3684 class CHandlerGameConfigCancel: public IActionHandler
3685 {
3686 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
3687 {
3688 // Has something special to do only with screen aspect ratio:
3689 // - Video Modes changes are only really validated at apply times so cancel => noop
3690 // - All other standard changes are handled upper by ddx_cancel AH called
3691
3692 // restore the bkuped Screen AR and invalidate clientcfg (NB: don't need to save, since canceled)
3693 ClientCfg.ScreenAspectRatio= CHandlerGameConfigInit::BkupScreenAspectRatio;
3694 ClientCfg.writeDouble("ScreenAspectRatio", ClientCfg.ScreenAspectRatio);
3695 ClientCfg.IsInvalidated = true;
3696 }
3697 };
3698 REGISTER_ACTION_HANDLER(CHandlerGameConfigCancel, "game_config_cancel");
3699
3700
3701 // ***************************************************************************
3702 class CHandlerGameConfigChangeScreenRatioMode : public IActionHandler
3703 {
3704 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
3705 {
3706 if (CInterfaceLink::isUpdatingAllLinks()) return; // don't want to trash the value in client.cfg at init, due to 'updateAllLinks' being called
3707
3708 CInterfaceManager *pIM= CInterfaceManager::getInstance();
3709
3710 // get the current mode
3711 sint oldMode= NLGUI::CDBManager::getInstance()->getDbProp("UI:TEMP:SCREEN_RATIO_MODE")->getOldValue32();
3712 sint mode= NLGUI::CDBManager::getInstance()->getDbProp("UI:TEMP:SCREEN_RATIO_MODE")->getValue32();
3713 if(mode<0 || mode>3)
3714 return;
3715
3716 // If predef value (4/3 or 16/9)
3717 if(mode!=2)
3718 {
3719 switch(mode)
3720 {
3721 case 0: ClientCfg.ScreenAspectRatio= 1.33333f; break;
3722 case 1: ClientCfg.ScreenAspectRatio= 1.77777f; break;
3723 case 3: ClientCfg.ScreenAspectRatio= 0.f; break;
3724 }
3725 ClientCfg.writeDouble("ScreenAspectRatio", ClientCfg.ScreenAspectRatio);
3726
3727 // set content, and freeze the edit box
3728 CGroupEditBox *eb= dynamic_cast<CGroupEditBox*>( CWidgetManager::getInstance()->getElementFromDefine("game_config_screen_ratio_eb"));
3729 if(eb)
3730 {
3731 eb->setFrozen(true);
3732 eb->setInputStringAsFloat(ClientCfg.ScreenAspectRatio);
3733 }
3734 }
3735 // custom value
3736 else
3737 {
3738 // just unfreeze the edit box, and set correct value
3739 CGroupEditBox *eb= dynamic_cast<CGroupEditBox*>( CWidgetManager::getInstance()->getElementFromDefine("game_config_screen_ratio_eb"));
3740 if(eb)
3741 {
3742 eb->setFrozen(false);
3743 eb->setInputStringAsFloat(ClientCfg.ScreenAspectRatio);
3744 }
3745 }
3746
3747 // dirt the apply button of the DDX.
3748 // don't do it at init!
3749 if(oldMode!=-1)
3750 {
3751 CDDXManager *pDM = CDDXManager::getInstance();
3752 CInterfaceDDX *pDDX = pDM->get(GAME_CONFIG_DDX);
3753 if(pDDX)
3754 pDDX->validateApplyButton();
3755 }
3756
3757 // Invalidate the config
3758 ClientCfg.IsInvalidated = true;
3759 }
3760 };
3761 REGISTER_ACTION_HANDLER (CHandlerGameConfigChangeScreenRatioMode, "game_config_change_screen_ratio_mode");
3762
3763
3764 // ***************************************************************************
3765 class CHandlerGameConfigChangeAnisotropic : public IActionHandler
3766 {
3767 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
3768 {
3769 if (CInterfaceLink::isUpdatingAllLinks()) return; // don't want to trash the value in client.cfg at init, due to 'updateAllLinks' being called
3770
3771 CInterfaceManager *pIM = CInterfaceManager::getInstance();
3772
3773 // get values of anisotropic filtering
3774 sint oldAnisotropic = NLGUI::CDBManager::getInstance()->getDbProp(GAME_CONFIG_ANISOTROPIC_DB)->getOldValue32();
3775 sint anisotropic = NLGUI::CDBManager::getInstance()->getDbProp(GAME_CONFIG_ANISOTROPIC_DB)->getValue32();
3776
3777 // dirt the apply button of the DDX.
3778 // don't do it at init!
3779 if(oldAnisotropic != anisotropic && oldAnisotropic != -1 && anisotropic != -1)
3780 {
3781 CDDXManager *pDM = CDDXManager::getInstance();
3782 CInterfaceDDX *pDDX = pDM->get(GAME_CONFIG_DDX);
3783 if(pDDX)
3784 pDDX->validateApplyButton();
3785 }
3786 }
3787 };
3788 REGISTER_ACTION_HANDLER (CHandlerGameConfigChangeAnisotropic, "game_config_change_anisotropic");
3789
3790
3791 // ***************************************************************************
3792 class CHandlerGameConfigChangeScreenRatioCustom : public IActionHandler
3793 {
3794 virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
3795 {
3796 CInterfaceManager *pIM= CInterfaceManager::getInstance();
3797 sint mode= NLGUI::CDBManager::getInstance()->getDbProp("UI:TEMP:SCREEN_RATIO_MODE")->getValue32();
3798 if (mode != 2) return;
3799 CGroupEditBox *eb= dynamic_cast<CGroupEditBox*>( CWidgetManager::getInstance()->getElementFromDefine("game_config_screen_ratio_eb"));
3800 if(eb)
3801 {
3802 // validate the value
3803 float val= eb->getInputStringAsFloat();
3804 clamp(val, 0.1f, 10.f);
3805 // reset (to clamp precision also), and hence reget
3806 eb->setInputStringAsFloat(val);
3807 val= eb->getInputStringAsFloat();
3808
3809 // change the CFG with this value
3810 ClientCfg.ScreenAspectRatio= val;
3811 ClientCfg.writeDouble("ScreenAspectRatio", ClientCfg.ScreenAspectRatio);
3812
3813 // dirt the apply button of the DDX.
3814 {
3815 CDDXManager *pDM = CDDXManager::getInstance();
3816 CInterfaceDDX *pDDX = pDM->get(GAME_CONFIG_DDX);
3817 if(pDDX)
3818 pDDX->validateApplyButton();
3819 }
3820
3821 // Invalidate the config
3822 ClientCfg.IsInvalidated = true;
3823 }
3824 }
3825 };
3826 REGISTER_ACTION_HANDLER (CHandlerGameConfigChangeScreenRatioCustom, "game_config_change_screen_ratio_custom");
3827
3828 // ***************************************************************************
3829 class CHandlerSetInterfaceScale : public IActionHandler
3830 {
3831 virtual void execute (CCtrlBase *pCaller, const string &Params)
3832 {
3833 std::string s;
3834 s = getParam(Params, "scale");
3835 if (!s.empty()) {
3836 bool valid = false;
3837 if (nlstricmp(s, "auto") == 0 || s == "0")
3838 {
3839 valid = true;
3840 ClientCfg.InterfaceScaleAuto = true;
3841 }
3842 else
3843 {
3844 float scale;
3845 if (fromString(s, scale))
3846 {
3847 if (scale >= ClientCfg.InterfaceScale_min && scale <= ClientCfg.InterfaceScale_max)
3848 {
3849 valid = true;
3850 ClientCfg.InterfaceScale = scale;
3851 ClientCfg.InterfaceScaleAuto = false;
3852 }
3853 }
3854 }
3855
3856 if (valid)
3857 {
3858 ClientCfg.writeDouble("InterfaceScale", ClientCfg.InterfaceScale);
3859 ClientCfg.writeBool("InterfaceScaleAuto", ClientCfg.InterfaceScaleAuto);
3860 ClientCfg.IsInvalidated = true;
3861 return;
3862 }
3863 }
3864
3865 string help = "/setuiscale "+toString("%.1f .. %.1f", ClientCfg.InterfaceScale_min, ClientCfg.InterfaceScale_max);
3866 CInterfaceManager::getInstance()->displaySystemInfo("/setuiscale auto");
3867 CInterfaceManager::getInstance()->displaySystemInfo(help);
3868 }
3869 };
3870 REGISTER_ACTION_HANDLER (CHandlerSetInterfaceScale, "set_ui_scale");
3871
3872
3873 // ***************************************************************************
3874 class CHandlerGameMissionAbandon : public IActionHandler
3875 {
3876 virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
3877 {
3878 uint8 nMissionNb;
3879 fromString(Params, nMissionNb);
3880
3881 CCDBNodeLeaf *pNL = NLGUI::CDBManager::getInstance()->getDbProp("UI:TEMP:MISSION_ABANDON_BUTTON",false);
3882 if (pNL != NULL) pNL->setValue64(0);
3883
3884 sendMsgToServer("JOURNAL:MISSION_ABANDON", nMissionNb);
3885 }
3886 };
3887 REGISTER_ACTION_HANDLER (CHandlerGameMissionAbandon, "mission_abandon");
3888
3889
3890 // ***************************************************************************
3891 class CHandlerGameGroupMissionAbandon : public IActionHandler
3892 {
3893 virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
3894 {
3895 uint8 nMissionNb;
3896 fromString(Params, nMissionNb);
3897
3898 CCDBNodeLeaf *pNL = NLGUI::CDBManager::getInstance()->getDbProp("UI:TEMP:MISSION_ABANDON_BUTTON",false);
3899 if (pNL != NULL) pNL->setValue64(0);
3900
3901 sendMsgToServer("JOURNAL:GROUP_MISSION_ABANDON", nMissionNb);
3902 }
3903 };
3904 REGISTER_ACTION_HANDLER (CHandlerGameGroupMissionAbandon, "group_mission_abandon");
3905
3906
3907 // ***************************************************************************
3908 // ***************************************************************************
3909 // Yoyo New BotChat
3910 // ***************************************************************************
3911 // ***************************************************************************
3912
3913
3914 // ***************************************************************************
3915 // GCM Choose ZoneCharge
3916 // ***************************************************************************
3917 class CHandlerContextChooseZoneCharge : public IActionHandler
3918 {
3919 public:
3920 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
3921 {
3922 sendBotChatStart("START_CHOOSE_DUTY");
3923 BotChatPageAll->ChooseMission->setMissionClientType(MISSION_DESC::ZCCharge);
3924 CBotChatManager::getInstance()->setCurrPage(BotChatPageAll->ChooseMission);
3925 }
3926 };
3927 REGISTER_ACTION_HANDLER(CHandlerContextChooseZoneCharge, "context_choose_zc_charge");
3928
3929
3930 // ***************************************************************************
3931 // GCM Choose Building
3932 // ***************************************************************************
3933 class CHandlerContextChooseBuilding : public IActionHandler
3934 {
3935 public:
3936 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
3937 {
3938 // Choose a building is like choose a mission
3939 sendBotChatStart("START_CHOOSE_MISSION");
3940 BotChatPageAll->ChooseMission->setMissionClientType(MISSION_DESC::Building);
3941 CBotChatManager::getInstance()->setCurrPage(BotChatPageAll->ChooseMission);
3942 }
3943 };
3944 REGISTER_ACTION_HANDLER(CHandlerContextChooseBuilding, "context_choose_building");
3945
3946 // ***************************************************************************
3947 // GCM Buy RM
3948 // ***************************************************************************
3949 class CHandlerContextBuyRM : public IActionHandler
3950 {
3951 public:
3952 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
3953 {
3954 // Buy RM is like choose a mission
3955 sendBotChatStart("START_CHOOSE_MISSION");
3956 BotChatPageAll->ChooseMission->setMissionClientType(MISSION_DESC::RMBuy);
3957 CBotChatManager::getInstance()->setCurrPage(BotChatPageAll->ChooseMission);
3958 }
3959 };
3960 REGISTER_ACTION_HANDLER(CHandlerContextBuyRM, "context_buy_rm");
3961
3962 // ***************************************************************************
3963 // GCM Upgrade RM
3964 // ***************************************************************************
3965 class CHandlerContextUpgradeRM : public IActionHandler
3966 {
3967 public:
3968 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
3969 {
3970 // Upgrde RM is like choose a mission
3971 sendBotChatStart("START_CHOOSE_MISSION");
3972 BotChatPageAll->ChooseMission->setMissionClientType(MISSION_DESC::RMUpgrade);
3973 CBotChatManager::getInstance()->setCurrPage(BotChatPageAll->ChooseMission);
3974 }
3975 };
3976 REGISTER_ACTION_HANDLER(CHandlerContextUpgradeRM, "context_upgrade_rm");
3977
3978
3979 // ***************************************************************************
3980 // GCM Cancel Duty
3981 // ***************************************************************************
3982 class CHandlerContextCancelZoneCharge : public IActionHandler
3983 {
3984 public:
3985 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
3986 {
3987 CInterfaceManager *pIM= CInterfaceManager::getInstance();
3988
3989 // Check if user really want.
3990 pIM->validMessageBox(CInterfaceManager::QuestionIconMsg, CI18N::get("uiQCancelZoneCharge"),
3991 "do_cancel_zc_charge");
3992 }
3993 };
3994 REGISTER_ACTION_HANDLER(CHandlerContextCancelZoneCharge, "context_cancel_zc_charge");
3995
3996 // The Msg if Ok.
3997 class CHandlerDoCancelZoneCharge : public IActionHandler
3998 {
3999 public:
4000 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
4001 {
4002 sendMsgToServer("BOTCHAT:DUTY_CANCEL_APPLY");
4003 }
4004 };
4005 REGISTER_ACTION_HANDLER(CHandlerDoCancelZoneCharge, "do_cancel_zc_charge");
4006
4007
4008 // ***************************************************************************
4009 // GCM Destroy Building
4010 // ***************************************************************************
4011 class CHandlerContextDestroyBuilding : public IActionHandler
4012 {
4013 public:
4014 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
4015 {
4016 CInterfaceManager *pIM= CInterfaceManager::getInstance();
4017
4018 // Check if user really want.
4019 pIM->validMessageBox(CInterfaceManager::QuestionIconMsg, CI18N::get("uiQDestroyBuilding"),
4020 "do_destroy_building");
4021 }
4022 };
4023 REGISTER_ACTION_HANDLER(CHandlerContextDestroyBuilding, "context_destroy_building");
4024
4025 // The Msg if Ok.
4026 class CHandlerDoDestroyBuilding : public IActionHandler
4027 {
4028 public:
4029 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
4030 {
4031 sendMsgToServer("BOTCHAT:DESTROY_BUILDING");
4032 }
4033 };
4034 REGISTER_ACTION_HANDLER(CHandlerDoDestroyBuilding, "do_destroy_building");
4035
4036
4037 // ***************************************************************************
4038 // Combat defense interface handlers
4039 // ***************************************************************************
4040 // Select Parry.
4041 class CHandlerSelectParry : public IActionHandler
4042 {
4043 public:
4044 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
4045 {
4046 sendMsgToServer("COMBAT:PARRY");
4047
4048 // display parry mode msg
4049 CInterfaceManager *pIM= CInterfaceManager::getInstance();
4050 string msg = CI18N::get("msgUserModeParry");
4051 string cat = getStringCategory(msg, msg);
4052 pIM->displaySystemInfo(msg, cat);
4053 }
4054 };
4055 REGISTER_ACTION_HANDLER(CHandlerSelectParry, "parry");
4056
4057 // Select dodge.
4058 class CHandlerSelectDodge : public IActionHandler
4059 {
4060 public:
4061 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
4062 {
4063 sendMsgToServer("COMBAT:DODGE");
4064
4065 // display dodge mode msg
4066 CInterfaceManager *pIM= CInterfaceManager::getInstance();
4067 string msg = CI18N::get("msgUserModeDodge");
4068 string cat = getStringCategory(msg, msg);
4069 pIM->displaySystemInfo(msg, cat);
4070 }
4071 };
4072 REGISTER_ACTION_HANDLER(CHandlerSelectDodge, "dodge");
4073
4074 // Select protected slot.
4075 class CHandlerSelectProtectedSlot : public IActionHandler
4076 {
4077 public:
4078 void execute (CCtrlBase * /* pCaller */, const std::string &sParams)
4079 {
4080 uint8 slot = (uint8)SLOT_EQUIPMENT::stringToSlotEquipment(sParams);
4081 sendMsgToServer("COMBAT:PROTECTED_SLOT", slot);
4082 }
4083 };
4084 REGISTER_ACTION_HANDLER(CHandlerSelectProtectedSlot, "select_protected_slot");
4085
4086
4087 // ***************************************************************************
4088 // Tooltips for Players Stats, with values printed.
4089 // ***************************************************************************
4090
4091
4092 // ***************************************************************************
4093 // Common code
4094 static void fillPlayerBarText(std::string &str, const string &dbScore, SCORES::TScores score, const string &ttFormat)
4095 {
4096 CInterfaceManager *pIM= CInterfaceManager::getInstance();
4097 CCDBNodeLeaf *node;
4098
4099 sint val= 0;
4100 sint maxVal= 0;
4101 // Get from local database cause written from CBarManager, from a fast impulse
4102 node= NLGUI::CDBManager::getInstance()->getDbProp("UI:VARIABLES:USER:" + dbScore, false);
4103 if(node) val= node->getValue32();
4104 // less accurate/speed Max transferred by DB
4105 node= NLGUI::CDBManager::getInstance()->getDbProp(toString("SERVER:CHARACTER_INFO:SCORES%d:", score), false);
4106 if(node) maxVal= node->getValue32();
4107 val= max(val, 0);
4108 maxVal= max(maxVal, 0);
4109
4110 str= CI18N::get(ttFormat);
4111 strFindReplace(str, "%v", toString(val) );
4112 strFindReplace(str, "%m", toString(maxVal) );
4113 }
4114
4115 // ***************************************************************************
4116 // Life
4117 class CHandlerPlayerTTLife : public IActionHandler
4118 {
4119 public:
4120 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
4121 {
4122 CInterfaceManager *pIM= CInterfaceManager::getInstance();
4123
4124 string str;
4125 fillPlayerBarText(str, "HP", SCORES::hit_points, "uittPlayerLifeFormat");
4126
4127 CWidgetManager::getInstance()->setContextHelpText(str);
4128 }
4129 };
4130 REGISTER_ACTION_HANDLER(CHandlerPlayerTTLife, "player_tt_life");
4131
4132 // ***************************************************************************
4133 // Stamina
4134 class CHandlerPlayerTTStamina : public IActionHandler
4135 {
4136 public:
4137 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
4138 {
4139 CInterfaceManager *pIM= CInterfaceManager::getInstance();
4140
4141 string str;
4142 fillPlayerBarText(str, "STA", SCORES::stamina, "uittPlayerStaminaFormat");
4143
4144 CWidgetManager::getInstance()->setContextHelpText(str);
4145 }
4146 };
4147 REGISTER_ACTION_HANDLER(CHandlerPlayerTTStamina, "player_tt_stamina");
4148
4149 // ***************************************************************************
4150 // Sap
4151 class CHandlerPlayerTTSap : public IActionHandler
4152 {
4153 public:
4154 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
4155 {
4156 CInterfaceManager *pIM= CInterfaceManager::getInstance();
4157
4158 string str;
4159 fillPlayerBarText(str, "SAP", SCORES::sap, "uittPlayerSapFormat");
4160
4161 CWidgetManager::getInstance()->setContextHelpText(str);
4162 }
4163 };
4164 REGISTER_ACTION_HANDLER(CHandlerPlayerTTSap, "player_tt_sap");
4165
4166 // ***************************************************************************
4167 // Focus
4168 class CHandlerPlayerTTFocus : public IActionHandler
4169 {
4170 public:
4171 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
4172 {
4173 CInterfaceManager *pIM= CInterfaceManager::getInstance();
4174
4175 string str;
4176 fillPlayerBarText(str, "FOCUS", SCORES::focus, "uittPlayerFocusFormat");
4177
4178 CWidgetManager::getInstance()->setContextHelpText(str);
4179 }
4180 };
4181 REGISTER_ACTION_HANDLER(CHandlerPlayerTTFocus, "player_tt_focus");
4182
4183 // ***************************************************************************
4184 // Bulk: NB: work for player / animal
4185 class CHandlerGetTTBulk : public IActionHandler
4186 {
4187 public:
4188 void execute (CCtrlBase * /* pCaller */, const std::string &sParams)
4189 {
4190 CInterfaceManager *pIM= CInterfaceManager::getInstance();
4191 string dbBranch= getParam(sParams, "dbbranch");
4192 string dbMax= getParam(sParams, "dbmax");
4193
4194 // Get the sum of the bulk for this db branch
4195 const double epsilon = 0.001;
4196 float val = CInventoryManager::getBranchBulk(dbBranch, 0, 10000) + epsilon;
4197
4198 // Get the Max value
4199 sint32 maxVal= 0;
4200 CCDBNodeLeaf *node= NLGUI::CDBManager::getInstance()->getDbProp(dbMax, false);
4201 if(node)
4202 maxVal= node->getValue32();
4203
4204 // Replace in the formated text
4205 string str= CI18N::get("uittBulkFormat");
4206 strFindReplace(str, "%v", toString("%.2f", val) );
4207 strFindReplace(str, "%m", toString(maxVal) );
4208 CWidgetManager::getInstance()->setContextHelpText(str);
4209 }
4210 };
4211 REGISTER_ACTION_HANDLER(CHandlerGetTTBulk, "get_tt_bulk");
4212
4213 // ***************************************************************************
4214 #define UI_MISSION_LIST "ui:interface:info_player_journal:content:mission_list"
4215
4216 uint32 getMissionTitle(sint32 nSelected)
4217 {
4218 CInterfaceManager *pIM = CInterfaceManager::getInstance();
4219
4220 sint32 nNbMission, nNbGroupMission;
4221 fromString(CWidgetManager::getInstance()->getParser()->getDefine("ipj_nb_mission"), nNbMission);
4222 fromString(CWidgetManager::getInstance()->getParser()->getDefine("ipj_nb_group_mission"), nNbGroupMission);
4223
4224 if (nSelected < 0)
4225 return 0;
4226 else if (nSelected < nNbMission)
4227 return NLGUI::CDBManager::getInstance()->getDbProp("SERVER:MISSIONS:"+toString(nSelected)+":TITLE")->getValue32();
4228 else if (nSelected < (nNbMission+nNbGroupMission))
4229 return NLGUI::CDBManager::getInstance()->getDbProp("SERVER:GROUP:MISSIONS:"+toString(nSelected-nNbMission)+":TITLE")->getValue32();
4230 return 0;
4231 }
4232
4233 void runMissionProc(sint32 nSelected)
4234 {
4235 CInterfaceManager *pIM = CInterfaceManager::getInstance();
4236
4237 sint32 nNbMission, nNbGroupMission;
4238 fromString(CWidgetManager::getInstance()->getParser()->getDefine("ipj_nb_mission"), nNbMission);
4239 fromString(CWidgetManager::getInstance()->getParser()->getDefine("ipj_nb_group_mission"), nNbGroupMission);
4240
4241 if (nSelected < 0)
4242 return;
4243 else if (nSelected < nNbMission)
4244 {
4245 string sButtonPath = UI_MISSION_LIST ":b_title"+toString(nSelected);
4246 CCtrlButton *pCB = dynamic_cast<CCtrlButton*>(CWidgetManager::getInstance()->getElementFromId(sButtonPath));
4247 CAHManager::getInstance()->runActionHandler("proc", pCB, "mission_proc_title|"+toString(nSelected));
4248 }
4249 else if (nSelected < (nNbMission+nNbGroupMission))
4250 {
4251 string sButtonPath = UI_MISSION_LIST ":b_group_title"+toString(nSelected-nNbMission);
4252 CCtrlButton *pCB = dynamic_cast<CCtrlButton*>(CWidgetManager::getInstance()->getElementFromId(sButtonPath));
4253 CAHManager::getInstance()->runActionHandler("proc", pCB, "group_mission_proc_title|"+toString(nSelected-nNbMission));
4254 }
4255 return;
4256 }
4257
4258
4259 class CHandlerMissionChooseNextValid : public IActionHandler
4260 {
4261 public:
4262 void execute(CCtrlBase * /* pCaller */, const std::string &/* sParams */)
4263 {
4264 CInterfaceManager *pIM = CInterfaceManager::getInstance();
4265 sint32 nSelected = NLGUI::CDBManager::getInstance()->getDbProp("UI:SAVE:MISSION_SELECTED")->getValue32();
4266
4267 sint32 nNbMission, nNbGroupMission;
4268 fromString(CWidgetManager::getInstance()->getParser()->getDefine("ipj_nb_mission"), nNbMission);
4269 fromString(CWidgetManager::getInstance()->getParser()->getDefine("ipj_nb_group_mission"), nNbGroupMission);
4270
4271 // If no mission selected or title selected becomes invalid -> search a new title to select
4272 if ((nSelected == -1) || (getMissionTitle(nSelected) == 0))
4273 {
4274 bool bFound = false;
4275 sint32 nSel = nSelected;
4276
4277 // From the currently selected mission go backward (in the display order)
4278 if (nSel != -1)
4279 while (!bFound)
4280 {
4281 nSel--;
4282 if (nSel < 0)
4283 break;
4284
4285 // Is there a mission at the position nSel ? Yes ok select !
4286 if (getMissionTitle(nSel) != 0)
4287 {
4288 runMissionProc(nSel);
4289 return;
4290 }
4291 }
4292 // Ok not found a mission in backward mode try now in forward mode until the end of the mission list
4293 while (!bFound)
4294 {
4295 nSel++;
4296 if (nSel == (nNbMission+nNbGroupMission))
4297 break;
4298
4299 // Is there a mission at the position nSel ? Yes ok select !
4300 if (getMissionTitle(nSel) != 0)
4301 {
4302 runMissionProc(nSel);
4303 return;
4304 }
4305 }
4306 // No mission at all found so there is no mission in the journal
4307 NLGUI::CDBManager::getInstance()->getDbProp("UI:SAVE:MISSION_SELECTED")->setValue32(-1);
4308 }
4309 }
4310 };
4311 REGISTER_ACTION_HANDLER(CHandlerMissionChooseNextValid, "mission_choose_next_valid");
4312
4313 // ***************************************************************************
4314 // Output a text above the entity like hit points
4315 class CHandlerEntityFlyingText : public IActionHandler
4316 {
4317 public:
4318 void execute (CCtrlBase * /* pCaller */, const std::string &sParams)
4319 {
4320 string text = getParam(sParams, "text");
4321
4322 uint entity;
4323 fromString(getParam(sParams, "entity"), entity);
4324
4325 CRGBA color = CRGBA::stringToRGBA(getParam(sParams, "color").c_str());
4326 if (entity < 256)
4327 EntitiesMngr.entity (entity)->addHPOutput (CI18N::get (text), color);
4328 }
4329 };
4330 REGISTER_ACTION_HANDLER(CHandlerEntityFlyingText, "entity_flying_text");
4331
4332
4333 // ***************************************************************************
4334 // play an event music
4335 class CHandlerPlayEventMusic : public IActionHandler
4336 {
4337 public:
4338 void execute (CCtrlBase * /* pCaller */, const std::string &sParams)
4339 {
4340 bool loop = getParam(sParams, "loop")=="1";
4341
4342 uint xFade;
4343 fromString(getParam(sParams, "xfade"), xFade);
4344
4345 string fileName = getParam(sParams, "music");
4346
4347 // don't play if db is in init stage
4348 if (!ClientCfg.Local && IngameDbMngr.initInProgress()) return;
4349
4350 if(SoundMngr)
4351 SoundMngr->playEventMusic(fileName, xFade, loop);
4352 }
4353 };
4354 REGISTER_ACTION_HANDLER(CHandlerPlayEventMusic, "play_event_music");
4355
4356
4357 // ***************************************************************************
4358 // stop an event music
4359 class CHandlerStopEventMusic : public IActionHandler
4360 {
4361 public:
4362 void execute (CCtrlBase * /* pCaller */, const std::string &sParams)
4363 {
4364 uint xFade;
4365 fromString(getParam(sParams, "xfade"), xFade);
4366
4367 string fileName= getParam(sParams, "music");
4368
4369 // don't play if db is in init stage
4370 if (!ClientCfg.Local && IngameDbMngr.initInProgress()) return;
4371
4372 if(SoundMngr)
4373 SoundMngr->stopEventMusic(fileName, xFade);
4374 }
4375 };
4376 REGISTER_ACTION_HANDLER(CHandlerStopEventMusic, "stop_event_music");
4377
4378 // ***************************************************************************
4379 // enter cr zone for queue
4380 class CEnterCRZone: public IActionHandler
4381 {
4382 public:
4383 void execute (CCtrlBase * /* pCaller */, const std::string &sParams)
4384 {
4385 // hide interface
4386 CInterfaceManager* pIM = CInterfaceManager::getInstance();
4387 CInterfaceGroup *pIG = (CInterfaceGroup*)CWidgetManager::getInstance()->getElementFromId ("ui:interface:enter_crzone_proposal");
4388 if(pIG)
4389 pIG->setActive(false);
4390
4391 bool accept;
4392 fromString(sParams, accept);
4393 CBitMemStream out;
4394 if(GenericMsgHeaderMngr.pushNameToStream("MISSION:ENTER_CRITICAL", out))
4395 {
4396 //nlinfo("impulseCallBack :MISSION:ENTER_CRITICAL sent");
4397 out.serial(accept);
4398 NetMngr.push(out);
4399 }
4400 else
4401 {
4402 nlwarning("command : unknown message name : MISSION:ENTER_CRITICAL");
4403 }
4404 }
4405 };
4406 REGISTER_ACTION_HANDLER(CEnterCRZone, "enter_crzone");
4407
4408
4409 // ***************************************************************************
4410 // wake player
4411 class CWakeForMission : public IActionHandler
4412 {
4413 public:
4414 void execute (CCtrlBase * /* pCaller */, const std::string &sParams)
4415 {
4416 uint8 nMissionNb;
4417 fromString(sParams, nMissionNb);
4418
4419 CCDBNodeLeaf *pNL = NLGUI::CDBManager::getInstance()->getDbProp("UI:TEMP:MISSION_WAKE_BUTTON",false);
4420 if (pNL != NULL) pNL->setValue64(0);
4421
4422 sendMsgToServer("MISSION:WAKE", nMissionNb);
4423 }
4424 };
4425 REGISTER_ACTION_HANDLER(CWakeForMission, "mission_wake");
4426
4427 // ***************************************************************************
4428 // wake player
4429 class CWakeForGroupMission : public IActionHandler
4430 {
4431 public:
4432 void execute (CCtrlBase * /* pCaller */, const std::string &sParams)
4433 {
4434 uint8 nMissionNb;
4435 fromString(sParams, nMissionNb);
4436
4437 CCDBNodeLeaf *pNL = NLGUI::CDBManager::getInstance()->getDbProp("UI:TEMP:MISSION_WAKE_BUTTON",false);
4438 if (pNL != NULL) pNL->setValue64(0);
4439
4440 sendMsgToServer("MISSION:GROUP_WAKE", nMissionNb);
4441 }
4442 };
4443 REGISTER_ACTION_HANDLER(CWakeForGroupMission, "group_mission_wake");
4444
4445
4446 // ***************************************************************************
4447 // ***************************************************************************
4448 // PVP FACTION
4449 // ***************************************************************************
4450 // ***************************************************************************
4451
4452
4453 // ***************************************************************************
4454 class CBuildTotem : public IActionHandler
4455 {
4456 public:
4457 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
4458 {
4459 if (UserEntity->selection())
4460 {
4461 CEntityCL *pSel = EntitiesMngr.entity(UserEntity->selection());
4462 if (pSel != NULL)
4463 UserEntity->moveToTotemBuildingPhrase( UserEntity->selection(), 2.0f, std::numeric_limits<uint>::max(), std::numeric_limits<uint>::max(), true);
4464 }
4465 }
4466 };
4467 REGISTER_ACTION_HANDLER(CBuildTotem, "build_totem");
4468
4469
4470 // ***************************************************************************
4471 class CHandlerFameSetNeutral : public IActionHandler
4472 {
4473 public:
4474 void execute (CCtrlBase * /* pCaller */, const std::string &sParams)
4475 {
4476 if( IngameDbMngr.initInProgress() ) return;
4477
4478 bool force;
4479 fromString(getParam(sParams, "force"), force);
4480
4481 bool isCiv= getParam(sParams, "type")=="civ" || getParam(sParams, "type")=="civ_guild";
4482 bool isGuild= getParam(sParams, "type")=="civ_guild" || getParam(sParams, "type")=="cult_guild";
4483
4484 if(force)
4485 {
4486 // help the server to know what type of neutral to set (civ or cult). ugly
4487 uint8 u8Type= isCiv?PVP_CLAN::Fyros:PVP_CLAN::Kami;
4488 // send msg to server.
4489 if(isGuild)
4490 sendMsgToServer("PVP:SET_NEUTRAL_ALLEGIANCE_GUILD", u8Type);
4491 else
4492 sendMsgToServer("PVP:SET_NEUTRAL_ALLEGIANCE", u8Type);
4493 }
4494 else
4495 {
4496 // confirm first
4497 CInterfaceManager *pIM= CInterfaceManager::getInstance();
4498 if(isGuild)
4499 {
4500 pIM->validMessageBox(CInterfaceManager::WarningIconMsg,
4501 isCiv?CI18N::get("uiFameAllegianceCivSetNeutralGuildWarning"):
4502 CI18N::get("uiFameAllegianceCultSetNeutralGuildWarning"),
4503 "fame_set_neutral",
4504 isCiv?"type=civ_guild|force=1":"type=cult_guild|force=1" );
4505 }
4506 else
4507 {
4508 pIM->validMessageBox(CInterfaceManager::WarningIconMsg,
4509 isCiv?CI18N::get("uiFameAllegianceCivSetNeutralWarning"):
4510 CI18N::get("uiFameAllegianceCultSetNeutralWarning"),
4511 "fame_set_neutral",
4512 isCiv?"type=civ|force=1":"type=cult|force=1" );
4513 }
4514 }
4515 }
4516 };
4517 REGISTER_ACTION_HANDLER(CHandlerFameSetNeutral, "fame_set_neutral");
4518
4519
4520 // ***************************************************************************
4521 class CHandlerConfigureQuitDialogBox : public IActionHandler
4522 {
4523 public:
4524 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
4525 {
4526 CInterfaceManager::getInstance()->configureQuitDialogBox();
4527 }
4528 };
4529 REGISTER_ACTION_HANDLER(CHandlerConfigureQuitDialogBox, "configure_quit_dialog_box");
4530
4531 // ----------------------------------------------------------------------------
4532 static bool isSwimming()
4533 {
4534 if (UserEntity != NULL)
4535 return (UserEntity->mode() == MBEHAV::SWIM || UserEntity->mode() == MBEHAV::MOUNT_SWIM);
4536 else
4537 return false;
4538 }
4539
4540 static bool isStunned()
4541 {
4542 if (UserEntity != NULL)
4543 return (UserEntity->behaviour() == MBEHAV::STUNNED);
4544 else
4545 return false;
4546 }
4547
4548 static bool isDead()
4549 {
4550 if (UserEntity != NULL)
4551 return (UserEntity->mode() == MBEHAV::DEATH);
4552 else
4553 return false;
4554 }
4555
4556 // ***************************************************************************
4557
4558 class CHandlerEmote : public IActionHandler
4559 {
4560 public:
4561 void execute (CCtrlBase * /* pCaller */, const std::string &sParams)
4562 {
4563 // An emote is 2 things : a phrase and an animation
4564 // Phrase is the phrase that server returns in chat system
4565 // Behav is the animation played
4566 // CustomPhrase is an user phrase which can replace default phrase
4567 string sPhraseNb = getParam(sParams, "nb");
4568 string sBehav = getParam(sParams, "behav");
4569 string sCustomPhrase = getParam(sParams, "custom_phrase");
4570
4571 uint32 phraseNb;
4572 fromString(sPhraseNb, phraseNb);
4573 uint8 behaviour;
4574 fromString(sBehav, behaviour);
4575
4576 MBEHAV::EBehaviour behavToSend = (MBEHAV::EBehaviour)(MBEHAV::EMOTE_BEGIN + behaviour);
4577 uint16 phraseNbToSend = (uint16)phraseNb;
4578
4579 if (EAM)
4580 {
4581 const uint nbBehav = EAM->getNbEmots(); // Miscalled: this is the number of behaviour for all emotes
4582 if ((behaviour >= nbBehav) || (behaviour == 255))
4583 behavToSend = MBEHAV::IDLE;
4584 }
4585 else
4586 {
4587 if (behaviour == 255)
4588 behavToSend = MBEHAV::IDLE;
4589 }
4590
4591 /* Emotes forbidden when dead, emotes with behav forbidden when
4592 * stunned or swimming */
4593 if ( ( behavToSend != MBEHAV::IDLE && (isSwimming() || isStunned() || isDead() ) ) )
4594 {
4595 return;
4596 }
4597
4598 if( sCustomPhrase.empty() )
4599 {
4600 // Create the message and send.
4601 static const char *msgName = "COMMAND:EMOTE";
4602 CBitMemStream out;
4603 if(GenericMsgHeaderMngr.pushNameToStream(msgName, out))
4604 {
4605 out.serialEnum(behavToSend);
4606 out.serial(phraseNbToSend);
4607 NetMngr.push(out);
4608 //nlinfo("impulseCallBack : %s %d %d sent", msgName.c_str(), (uint32)behavToSend, phraseNbToSend);
4609 }
4610 else
4611 nlwarning("command 'emote': unknown message named '%s'.", msgName);
4612 }
4613 else
4614 {
4615 // Create the message and send.
4616 static const char *msgName = "COMMAND:CUSTOM_EMOTE";
4617 CBitMemStream out;
4618 if(GenericMsgHeaderMngr.pushNameToStream(msgName, out))
4619 {
4620 ucstring ucstr; // FIXME: UTF-8 (serial)
4621 ucstr.fromUtf8(sCustomPhrase);
4622
4623 if( sCustomPhrase == "none" )
4624 {
4625 if( behavToSend == MBEHAV::IDLE )
4626 {
4627 // display "no animation for emote"
4628 CInterfaceManager *pIM= CInterfaceManager::getInstance();
4629 string msg = CI18N::get("msgCustomizedEmoteNoAnim");
4630 string cat = getStringCategory(msg, msg);
4631 pIM->displaySystemInfo(msg, cat);
4632 return;
4633 }
4634 }
4635 else
4636 {
4637 ucstr = ucstring("&EMT&") + UserEntity->getDisplayName() + ucstring(" ") + ucstr; // FIXME: UTF-8 (serial)
4638 }
4639
4640 out.serialEnum(behavToSend);
4641 out.serial(ucstr); // FIXME: UTF-8 (serial)
4642 NetMngr.push(out);
4643 //nlinfo("impulseCallBack : %s %d %s sent", msgName.c_str(), (uint32)behavToSend, sCustomPhrase.c_str());
4644 }
4645 else
4646 nlwarning("command 'emote': unknown message named '%s'.", msgName);
4647 }
4648 }
4649 };
4650 REGISTER_ACTION_HANDLER( CHandlerEmote, "emote");
4651
4652 //=================================================================================================================
4653 class CHandlerSortTribeFame : public IActionHandler
4654 {
4655 public:
4656 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
4657 {
4658 CGroupList * list = dynamic_cast<CGroupList*>(CWidgetManager::getInstance()->getElementFromId("ui:interface:fame:content:tribes:list"));
4659 if (list && list->getNumChildren() > 1)
4660 {
4661 uint nbChilds = list->getNumChildren();
4662
4663 // std::collate does not work with ucchar
4664 std::vector<string> names;
4665
4666 for (uint i = 0; i < nbChilds; ++i)
4667 {
4668 CInterfaceGroup *pIG = dynamic_cast<CInterfaceGroup*>(list->getChild(i));
4669 if (!pIG) break;
4670
4671 CViewText *pVT = dynamic_cast<CViewText *>(pIG->getView("t"));
4672 if (!pVT) break;
4673
4674 names.push_back(toUpper(pVT->getText()));
4675 }
4676
4677 if (names.size() != nbChilds)
4678 {
4679 nlwarning("Failed to sort tribe fame list");
4680 return;
4681 }
4682
4683 std::locale loc("");
4684 const std::collate<char>& coll = std::use_facet<std::collate<char> >(loc); // FIXME: Probably does not work
4685
4686 for(uint i = 0; i < nbChilds - 1; ++i)
4687 {
4688 uint imin = i;
4689 for(uint j = i; j < nbChilds; j++)
4690 {
4691 // simple comparison fails with accented letters
4692 if (coll.compare(names[j].c_str(), names[j].c_str() + names[j].size(),
4693 names[imin].c_str(), names[imin].c_str() + names[imin].size()) < 0)
4694 {
4695 imin = j;
4696 }
4697 }
4698 if (imin != i)
4699 {
4700 list->swapChildren(i, imin);
4701 std::swap(names[i], names[imin]);
4702 }
4703 }
4704
4705 list->invalidateCoords();
4706 }
4707 }
4708 };
4709 REGISTER_ACTION_HANDLER( CHandlerSortTribeFame, "sort_tribefame");
4710
4711 // ***************************************************************************
4712 class CHandlerOutgameNaviGetKeys : public IActionHandler
4713 {
4714 virtual void execute (CCtrlBase *pCaller, const std::string &Params)
4715 {
4716 if (!pCaller->getParent())
4717 return;
4718
4719 if (pCaller->getParent()->getId() != "ui:outgame")
4720 return;
4721
4722 if (Params.empty())
4723 {
4724 sint32 event = -1;
4725
4726 if (Driver->AsyncListener.isKeyPushed(KeyESCAPE)) event = 0;
4727 if (Driver->AsyncListener.isKeyPushed(KeyDELETE)) event = 1;
4728 if (Driver->AsyncListener.isKeyPushed(KeyRETURN)) event = 2;
4729 if (Driver->AsyncListener.isKeyPushed(KeyDOWN)) event = 3;
4730 if (Driver->AsyncListener.isKeyPushed(KeyUP)) event = 4;
4731 if (Driver->AsyncListener.isKeyPushed(KeyI)) event = 5;
4732 if (Driver->AsyncListener.isKeyPushed(KeyP)) event = 6;
4733 if (Driver->AsyncListener.isKeyPushed(KeyE)) event = 7;
4734 if (Driver->AsyncListener.isKeyPushed(KeyLEFT)) event = 8;
4735 if (Driver->AsyncListener.isKeyPushed(KeyRIGHT)) event = 9;
4736
4737 std::string id = "create";
4738 if (pCaller->getId() == "ui:outgame:charsel")
4739 id = "sel";
4740
4741 if (event != -1)
4742 CLuaManager::getInstance().executeLuaScript(toString("outgame:eventChar%sKeyGet(%i)", id.c_str(), event));
4743 }
4744 // reset previous input
4745 Driver->AsyncListener.reset();
4746 }
4747 };
4748 REGISTER_ACTION_HANDLER( CHandlerOutgameNaviGetKeys, "navigate_outgame" );
4749
4750 // ***************************************************************************
4751 class CHandlerTriggerIconBuffs : public IActionHandler
4752 {
4753 public:
4754 void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
4755 {
4756 CCDBNodeLeaf *node = NLGUI::CDBManager::getInstance()->getDbProp("UI:SAVE:SHOW_ICON_BUFFS", false);
4757 // no node - show,
4758 // node == false - hide
4759 CDBCtrlSheet::setShowIconBuffs(!node || node->getValueBool());
4760 }
4761 };
4762 REGISTER_ACTION_HANDLER(CHandlerTriggerIconBuffs, "trigger_show_icon_buffs");
4763