ryzom/client/src/interface_v3/action_handler_outpost.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  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) 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 #include "stdpch.h"
  22
  23 // Interface includes
  24 #include "interface_manager.h"
  25 #include "nel/gui/action_handler.h"
  26 #include "action_handler_tools.h"
  27 #include "game_share/outpost.h"
  28 #include "nel/gui/interface_expr.h"
  29 #include "group_map.h"
  30 #include "../sheet_manager.h"
  31 #include "../net_manager.h"
  32 #include "../game_context_menu.h"
  33 #include "../user_entity.h"
  34 #include "../entities.h"
  35 #include "../outpost_manager.h"
  36
  37 using namespace std;
  38 using namespace NL3D;
  39 using namespace NLMISC;
  40
  41
  42 // ***************************************************************************
  43 // ***************************************************************************
  44 //                                                      OUTPOST HANDLERS
  45 // ***************************************************************************
  46 // ***************************************************************************
  47
  48 uint8 getOutpostSelection()
  49 {
  50         uint8 nOutpost = 0;
  51         CCDBNodeLeaf *pNL = NLGUI::CDBManager::getInstance()->getDbProp("UI:TEMP:OUTPOST:SELECTION",false);
  52         if (pNL != NULL)
  53                 nOutpost = (uint8)pNL->getValue32();
  54         return nOutpost;
  55 }
  56
  57 uint32 getOutpostSheet()
  58 {
  59         uint32  sheet= 0;
  60         uint8   outpostSel= getOutpostSelection();
  61         CCDBNodeLeaf *pNL = NLGUI::CDBManager::getInstance()->getDbProp(toString("SERVER:GUILD:OUTPOST:O%d:SHEET", outpostSel),false);
  62         if (pNL != NULL)
  63                 sheet = pNL->getValue32();
  64         return sheet;
  65 }
  66
  67 // ***************************************************************************
  68 // Abandon an outpost
  69 class COutpostGiveup : public IActionHandler
  70 {
  71 public:
  72         void execute (CCtrlBase * /* pCaller */, const std::string &sParams)
  73         {
  74                 CInterfaceManager       *pIM= CInterfaceManager::getInstance();
  75
  76                 // set confirm dialog flag
  77                 NLGUI::CDBManager::getInstance()->getDbProp("UI:TEMP:OUTPOST:CONFIRM_DEL_OUTPOST")->setValueBool(true);
  78
  79                 // Ask if ok before.
  80                 pIM->validMessageBox(CInterfaceManager::QuestionIconMsg, CI18N::get("uiQConfirmGiveupOutpost"),
  81                         "outpost_do_giveup", sParams, "outpost_cancel_giveup");
  82         }
  83 };
  84 REGISTER_ACTION_HANDLER(COutpostGiveup, "outpost_giveup");
  85
  86 class COutpostDoGiveup : public IActionHandler
  87 {
  88 public:
  89         void execute (CCtrlBase * /* pCaller */, const std::string &sParams)
  90         {
  91                 // retrieve the sheet of this outpost
  92                 uint32  sheet= 0;
  93                 uint8   outpostSel;
  94                 fromString(sParams, outpostSel);
  95                 CCDBNodeLeaf *pNL = NLGUI::CDBManager::getInstance()->getDbProp(toString("SERVER:GUILD:OUTPOST:O%d:SHEET", outpostSel),false);
  96                 if (pNL == NULL)
  97                         return;
  98                 sheet = pNL->getValue32();
  99
 100                 // send msg to server
 101                 sendMsgToServer("OUTPOST:GIVEUP_OUTPOST", sheet);
 102
 103                 // reset confirm dialog flag
 104                 CInterfaceManager       *pIM= CInterfaceManager::getInstance();
 105                 NLGUI::CDBManager::getInstance()->getDbProp("UI:TEMP:OUTPOST:CONFIRM_DEL_OUTPOST")->setValueBool(false);
 106         }
 107 };
 108 REGISTER_ACTION_HANDLER(COutpostDoGiveup, "outpost_do_giveup");
 109
 110 class COutpostCancelGiveup : public IActionHandler
 111 {
 112 public:
 113         void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
 114         {
 115                 // reset confirm dialog flag
 116                 CInterfaceManager       *pIM= CInterfaceManager::getInstance();
 117                 NLGUI::CDBManager::getInstance()->getDbProp("UI:TEMP:OUTPOST:CONFIRM_DEL_OUTPOST")->setValueBool(false);
 118         }
 119 };
 120 REGISTER_ACTION_HANDLER(COutpostCancelGiveup, "outpost_cancel_giveup");
 121
 122 // ***************************************************************************
 123 // Set a squad To buy (list of squad given by the server)
 124 class COutpostSetSquad : public IActionHandler
 125 {
 126 public:
 127         void execute (CCtrlBase * /* pCaller */, const std::string &sParams)
 128         {
 129                 CInterfaceManager       *pIM= CInterfaceManager::getInstance();
 130
 131                 // get Squad slot Destination selected
 132                 uint8 nSquadSlot = NLGUI::CDBManager::getInstance()->getDbProp("UI:TEMP:OUTPOST:SQUAD_SLOT_SELECTED")->getValue8();
 133
 134                 // get Squad Id to buy selected
 135                 string sLine = getParam(sParams, "line");
 136                 CInterfaceExprValue ievLine;
 137                 uint8 nLine = 0;
 138                 if (!CInterfaceExpr::eval(sLine, ievLine))
 139                 {
 140                         nlwarning("<COutpostBuy::execute> : Can't evaluate line");
 141                         return;
 142                 }
 143                 if (ievLine.getInteger() >= 0)
 144                         nLine = (uint8)ievLine.getInteger();
 145
 146                 // send msg
 147                 sendMsgToServer("OUTPOST:SET_SQUAD", getOutpostSheet(), nSquadSlot, nLine);
 148         }
 149 };
 150 REGISTER_ACTION_HANDLER(COutpostSetSquad, "outpost_set_squad");
 151
 152
 153 // ***************************************************************************
 154 // Remove a squad To buy (list of squad given by the server)
 155 class COutpostRemoveSquad : public IActionHandler
 156 {
 157 public:
 158         void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
 159         {
 160                 CInterfaceManager       *pIM= CInterfaceManager::getInstance();
 161
 162                 // get Squad slot Destination selected
 163                 uint8 nSquadSlot = NLGUI::CDBManager::getInstance()->getDbProp("UI:TEMP:OUTPOST:SQUAD_SLOT_SELECTED")->getValue8();
 164
 165                 // send msg
 166                 sendMsgToServer("OUTPOST:REMOVE_SQUAD", getOutpostSheet(), nSquadSlot);
 167         }
 168 };
 169 REGISTER_ACTION_HANDLER(COutpostRemoveSquad, "outpost_remove_squad");
 170
 171 // ***************************************************************************
 172 // Insert a squad To buy (list of squad given by the server)
 173 class COutpostInsertSquad : public IActionHandler
 174 {
 175 public:
 176         void execute (CCtrlBase *pCaller, const std::string &sParams)
 177         {
 178                 CInterfaceManager       *pIM= CInterfaceManager::getInstance();
 179
 180                 // get Squad slot Destination selected
 181                 uint8 nSquadSlot = NLGUI::CDBManager::getInstance()->getDbProp("UI:TEMP:OUTPOST:SQUAD_SLOT_SELECTED")->getValue8();
 182
 183                 // send msg
 184                 sendMsgToServer("OUTPOST:INSERT_SQUAD", getOutpostSheet(), nSquadSlot);
 185
 186                 // Then set the selected squad at this place
 187                 CAHManager::getInstance()->runActionHandler("outpost_set_squad", pCaller, sParams);
 188         }
 189 };
 190 REGISTER_ACTION_HANDLER(COutpostInsertSquad, "outpost_insert_squad");
 191
 192 // ***************************************************************************
 193 // Map helper
 194 uint8 getOutpostSquadSpawnIndex()
 195 {
 196         CInterfaceManager *pIM = CInterfaceManager::getInstance();
 197
 198         // get Squad slot
 199         uint8 nSquadSlot = NLGUI::CDBManager::getInstance()->getDbProp("UI:TEMP:OUTPOST:SQUAD_SLOT_SELECTED")->getValue8();
 200
 201         // So we can get the spawn index stored in the DB
 202         string sDBPath = "SERVER:GUILD:OUTPOST:O" + toString(getOutpostSelection()) + ":SQUADS:T";
 203         sDBPath += toString(nSquadSlot) + ":SPAWN";
 204         return NLGUI::CDBManager::getInstance()->getDbProp(sDBPath)->getValue8();
 205 }
 206
 207 // ***************************************************************************
 208 class COutpostInitSquadMap : public IActionHandler
 209 {
 210 public:
 211         void execute (CCtrlBase * /* pCaller */, const std::string &sParams)
 212         {
 213                 CInterfaceManager *pIM = CInterfaceManager::getInstance();
 214                 CGroupMap *pMap = dynamic_cast<CGroupMap*>(CWidgetManager::getInstance()->getElementFromId(sParams));
 215                 if (pMap == NULL)
 216                         return;
 217
 218                 // Get the spawn index (from selected squad)
 219                 uint8 nSpawnIndex = getOutpostSquadSpawnIndex();
 220
 221                 // *** Get the BBox of the outpost
 222                 // init map with all xy that are in SERVER:GUILD:OUTPOST:O#x:SQUAD_SPAWN_ZONE (if 0,0 not present)
 223                 string sDBPathSZ = "SERVER:GUILD:OUTPOST:O" + toString(getOutpostSelection()) + ":SQUAD_SPAWN_ZONE:";
 224                 sint32 xMin = 0, xMax = 0, yMin = 0, yMax = 0;
 225                 bool bInit = false;
 226                 uint32 i;
 227                 for (i = 0; i < OUTPOSTENUMS::OUTPOST_MAX_SPAWN_ZONE; ++i)
 228                 {
 229                         sint32 x = NLGUI::CDBManager::getInstance()->getDbProp(sDBPathSZ + toString(i) + ":X")->getValue32();
 230                         sint32 y = NLGUI::CDBManager::getInstance()->getDbProp(sDBPathSZ + toString(i) + ":Y")->getValue32();
 231                         if ((x != 0) || (y != 0))
 232                         {
 233                                 if (!bInit)
 234                                 {
 235                                         xMin = xMax = x;
 236                                         yMin = yMax = y;
 237                                         bInit = true;
 238                                 }
 239                                 else
 240                                 {
 241                                         if (x < xMin) xMin = x;
 242                                         if (x > xMax) xMax = x;
 243                                         if (y < yMin) yMin = y;
 244                                         if (y > yMax) yMax = y;
 245                                 }
 246                         }
 247                 }
 248
 249                 // *** Find the finest map that contains the 2 points xMin,yMin and xMax,yMax
 250                 CWorldSheet *pWorldSheet = dynamic_cast<CWorldSheet*>(SheetMngr.get(CSheetId("ryzom.world")));
 251                 if (pWorldSheet == NULL)
 252                         return;
 253
 254                 sint32 nMapFound = -1;
 255                 for (i = 0; i < pWorldSheet->Maps.size(); ++i)
 256                 {
 257                         SMap &rMap = pWorldSheet->Maps[i];
 258                         // Avoid 'world' map
 259                         if (!rMap.ContinentName.empty())
 260                         {
 261                                 // Is bouding box contains the 2 points ?
 262                                 if ((rMap.MinX < xMin) && (rMap.MinY < yMin) &&
 263                                         (rMap.MaxX > xMax) && (rMap.MaxY > yMax))
 264                                 {
 265                                         // Is there a map already found ?
 266                                         if (nMapFound == -1)
 267                                         {
 268                                                 nMapFound = i; // No, first map found
 269                                         }
 270                                         else    // Yes we have to compare with the previous map to keep the finest
 271                                         {
 272                                                 SMap &rMapFound = pWorldSheet->Maps[nMapFound];
 273                                                 if ((rMap.MaxX - rMap.MinX) < (rMapFound.MaxX - rMapFound.MinX))
 274                                                         nMapFound = i;
 275                                         }
 276                                 }
 277                         }
 278                 }
 279
 280                 // *** Setup the Map and zoom to outpost
 281                 if (nMapFound != -1)
 282                 {
 283                         SMap &rMapFound = pWorldSheet->Maps[nMapFound];
 284                         pMap->setMap(rMapFound.Name);
 285                         CVector2f centerWorldCoord((xMax + xMin)/2.0f, (yMin + yMax)/2.0f);
 286                         CVector2f centerMapCoord;
 287                         pMap->worldToMap(centerMapCoord, centerWorldCoord);
 288                         pMap->setScale((rMapFound.MaxX - rMapFound.MinX) / max(sint32(1), (xMax - xMin)) );
 289                         pMap->setPlayerPos(centerMapCoord);
 290                         pMap->centerOnPlayer();
 291
 292                         CRespawnPointsMsg m;
 293                         m.NeedToReset = true;
 294                         for (i = 0; i < OUTPOSTENUMS::OUTPOST_MAX_SPAWN_ZONE; ++i)
 295                         {
 296                                 sint32 x = NLGUI::CDBManager::getInstance()->getDbProp(sDBPathSZ + toString(i) + ":X")->getValue32();
 297                                 sint32 y = NLGUI::CDBManager::getInstance()->getDbProp(sDBPathSZ + toString(i) + ":Y")->getValue32();
 298                                 if ((x != 0) || (y != 0))
 299                                 {
 300                                         CRespawnPointsMsg::SRespawnPoint pt;
 301                                         pt.x = x * 1000;
 302                                         pt.y = y * 1000;
 303                                         m.RespawnPoints.push_back(pt);
 304                                 }
 305                         }
 306                         pMap->addRespawnPoints(m);
 307                         pMap->setRespawnSelected(nSpawnIndex);
 308                 }
 309         }
 310 };
 311 REGISTER_ACTION_HANDLER(COutpostInitSquadMap, "outpost_init_squad_map");
 312
 313 // ***************************************************************************
 314 class COutpostSquadMapSend : public IActionHandler
 315 {
 316 public:
 317         void execute (CCtrlBase * /* pCaller */, const std::string &sParams)
 318         {
 319                 CInterfaceManager *pIM = CInterfaceManager::getInstance();
 320                 CGroupMap *pMap = dynamic_cast<CGroupMap*>(CWidgetManager::getInstance()->getElementFromId(sParams));
 321                 if (pMap == NULL)
 322                         return;
 323
 324                 // Get the spawn index (from selected squad)
 325                 uint8 nSpawnIndex = getOutpostSquadSpawnIndex();
 326
 327                 // Get Spawn index selected by the user
 328                 uint8 nSpawnSelected = (uint8)pMap->getRespawnSelected();
 329
 330                 if (nSpawnIndex != nSpawnSelected)
 331                 {
 332                         // get Squad slot
 333                         uint8 nSquadSlot = NLGUI::CDBManager::getInstance()->getDbProp("UI:TEMP:OUTPOST:SQUAD_SLOT_SELECTED")->getValue8();
 334
 335                         sendMsgToServer("OUTPOST:SET_SQUAD_SPAWN", getOutpostSheet(), nSquadSlot, nSpawnSelected);
 336                 }
 337         }
 338 };
 339 REGISTER_ACTION_HANDLER(COutpostSquadMapSend, "outpost_squad_map_send");
 340
 341
 342 // ***************************************************************************
 343 class COutpostSelectSquadCapital : public IActionHandler
 344 {
 345 public:
 346         void execute(CCtrlBase * /* pCaller */, const std::string &params)
 347         {
 348                 uint32  capital;
 349                 fromString(params, capital);
 350                 sendMsgToServer("OUTPOST:SET_SQUAD_CAPITAL", getOutpostSheet(), capital);
 351         }
 352 };
 353 REGISTER_ACTION_HANDLER(COutpostSelectSquadCapital, "outpost_select_squad_capital");
 354
 355
 356 // ***************************************************************************
 357 static sint             localToGmt(sint hour)
 358 {
 359         CInterfaceManager       *pIM= CInterfaceManager::getInstance();
 360
 361         CCDBNodeLeaf    *node= NLGUI::CDBManager::getInstance()->getDbProp("UI:SAVE:OUTPOST:TIME_ZONE", false);
 362         if(node)
 363                 hour-= node->getValue32();
 364         hour+= 48;
 365         hour%=24;
 366
 367         return hour;
 368 }
 369 static sint             gmtToLocal(sint hour)
 370 {
 371         CInterfaceManager       *pIM= CInterfaceManager::getInstance();
 372
 373         CCDBNodeLeaf    *node= NLGUI::CDBManager::getInstance()->getDbProp("UI:SAVE:OUTPOST:TIME_ZONE", false);
 374         if(node)
 375                 hour+= node->getValue32();
 376         hour+= 48;
 377         hour%=24;
 378
 379         return hour;
 380 }
 381
 382
 383 // ***************************************************************************
 384 class CAHOutpostSelectDefPeriod : public IActionHandler
 385 {
 386 public:
 387         void execute (CCtrlBase * /* pCaller */, const std::string &sParams)
 388         {
 389                 // The user change the defense period (edited in LOCAL TimeZone)
 390                 sint defPeriod;
 391                 fromString(sParams, defPeriod);
 392
 393                 // Then send request to Server
 394                 sendMsgToServer("OUTPOST:SET_DEF_PERIOD", getOutpostSheet(), uint8(localToGmt(defPeriod)));
 395         }
 396 };
 397 REGISTER_ACTION_HANDLER(CAHOutpostSelectDefPeriod, "outpost_select_def_period");
 398
 399 // ***************************************************************************
 400 class CAHOutpostSelectAttPeriod : public IActionHandler
 401 {
 402 public:
 403         void execute (CCtrlBase *pCaller, const std::string &sParams)
 404         {
 405                 CInterfaceManager       *pIM= CInterfaceManager::getInstance();
 406
 407                 // The user change the attack period (edited in LOCAL TimeZone)
 408                 sint attPeriod;
 409                 fromString(sParams, attPeriod);
 410
 411                 // Store in local DB (in LOCAL for consistency)
 412                 CCDBNodeLeaf    *node= NLGUI::CDBManager::getInstance()->getDbProp("UI:TEMP:OUTPOST:DECLARE_WAR_ATTACK_PERIOD", false);
 413                 if(node)
 414                         node->setValue32(localToGmt(attPeriod));
 415
 416                 // Nead to resend a Declare War Start (because wanted Att Hour changed)
 417                 CAHManager::getInstance()->runActionHandler("outpost_declare_war_start", pCaller);
 418         }
 419 };
 420 REGISTER_ACTION_HANDLER(CAHOutpostSelectAttPeriod, "outpost_select_att_period");
 421
 422 // ***************************************************************************
 423 class CAHOutpostDeclareWarStart : public IActionHandler
 424 {
 425 public:
 426         void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
 427         {
 428                 CInterfaceManager       *pIM= CInterfaceManager::getInstance();
 429
 430                 // read current outpost sheet
 431                 uint32  outpostSheet= 0;
 432                 CCDBNodeLeaf    *node= NLGUI::CDBManager::getInstance()->getDbProp("SERVER:OUTPOST_SELECTED:SHEET", false);
 433                 if(node)
 434                         outpostSheet= node->getValue32();
 435
 436                 // read wanted GMT attack period
 437                 uint8   wantedAttHour= 0;
 438                 node= NLGUI::CDBManager::getInstance()->getDbProp("UI:TEMP:OUTPOST:DECLARE_WAR_ATTACK_PERIOD", false);
 439                 if(node)
 440                         wantedAttHour= (uint8)node->getValue32();
 441
 442                 // send a DECLARE_WAR_START message to server
 443                 sendMsgToServer("OUTPOST:DECLARE_WAR_START", outpostSheet, wantedAttHour);
 444         }
 445 };
 446 REGISTER_ACTION_HANDLER(CAHOutpostDeclareWarStart, "outpost_declare_war_start");
 447
 448 // ***************************************************************************
 449 class CAHOutpostDeclareWarValidate : public IActionHandler
 450 {
 451 public:
 452         void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
 453         {
 454                 CInterfaceManager       *pIM= CInterfaceManager::getInstance();
 455
 456                 // read current outpost sheet
 457                 uint32  outpostSheet= 0;
 458                 CCDBNodeLeaf    *node= NLGUI::CDBManager::getInstance()->getDbProp("SERVER:OUTPOST_SELECTED:SHEET", false);
 459                 if(node)
 460                         outpostSheet= node->getValue32();
 461
 462                 // read wanted GMT attack period
 463                 uint8   wantedAttHour= 0;
 464                 node= NLGUI::CDBManager::getInstance()->getDbProp("UI:TEMP:OUTPOST:DECLARE_WAR_ATTACK_PERIOD", false);
 465                 if(node)
 466                         wantedAttHour= (uint8)node->getValue32();
 467
 468                 // read result Att Period Time (NB: for final server check: ensure that the user will get what it sees)
 469                 uint32  startAttackTime= 0;
 470                 node= NLGUI::CDBManager::getInstance()->getDbProp("UI:TEMP:OUTPOST:DECLARE_WAR_ACK_TIME_RANGE_ATT", false);
 471                 if(node)
 472                         startAttackTime= node->getValue32();
 473
 474                 // send a DECLARE_WAR_VALIDATE message to server
 475                 const char *sMsg= "OUTPOST:DECLARE_WAR_VALIDATE";
 476                 CBitMemStream out;
 477                 if(GenericMsgHeaderMngr.pushNameToStream(sMsg, out))
 478                 {
 479                         //nlinfo("impulseCallBack : %s %d %d %d sent", sMsg.c_str(), outpostSheet, wantedAttHour, startAttackTime);
 480                         out.serial(outpostSheet);
 481                         out.serial(wantedAttHour);
 482                         out.serial(startAttackTime);
 483                         NetMngr.push(out);
 484                 }
 485                 else
 486                 {
 487                         nlwarning("command : unknown message name : '%s'.", sMsg);
 488                 }
 489
 490         }
 491 };
 492 REGISTER_ACTION_HANDLER(CAHOutpostDeclareWarValidate, "outpost_declare_war_validate");
 493
 494 // ***************************************************************************
 495 class CAHOutpostSelectFromBC : public IActionHandler
 496 {
 497 public:
 498         void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
 499         {
 500                 CInterfaceManager       *pIM= CInterfaceManager::getInstance();
 501
 502                 // Copy SERVER DB to Local selection
 503                 uint32  outpostSheet= 0;
 504                 CCDBNodeLeaf    *node= NLGUI::CDBManager::getInstance()->getDbProp("LOCAL:TARGET:CONTEXT_MENU:OUTPOST");
 505                 if(node)        outpostSheet= node->getValue32();
 506                 node= NLGUI::CDBManager::getInstance()->getDbProp("UI:TEMP:OUTPOST:BOT_SELECTION");
 507                 if(node)        node->setValue32(outpostSheet);
 508
 509                 // Send a msg to server
 510                 if(outpostSheet)
 511                 {
 512                         const char *sMsg= "OUTPOST:SELECT";
 513                         CBitMemStream out;
 514                         if(GenericMsgHeaderMngr.pushNameToStream(sMsg, out))
 515                         {
 516                                 //nlinfo("impulseCallBack : %s %d sent", sMsg.c_str(), outpostSheet);
 517                                 out.serial(outpostSheet);
 518                                 NetMngr.push(out);
 519                         }
 520                         else
 521                         {
 522                                 nlwarning("command : unknown message name : '%s'.", sMsg);
 523                         }
 524                 }
 525         }
 526 };
 527 REGISTER_ACTION_HANDLER(CAHOutpostSelectFromBC, "outpost_select_from_bc");
 528
 529
 530 // ***************************************************************************
 531 class CAHOutpostUnSelect : public IActionHandler
 532 {
 533 public:
 534         void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
 535         {
 536                 // Called when the Outpost State window (the one opened from BotChat) is closed
 537
 538                 // Send a msg to server
 539                 sendMsgToServer("OUTPOST:UNSELECT");
 540         }
 541 };
 542 REGISTER_ACTION_HANDLER(CAHOutpostUnSelect, "outpost_unselect");
 543
 544
 545 // ***************************************************************************
 546 class CAHOutpostPVPJoin : public IActionHandler
 547 {
 548 public:
 549         void    execute (CCtrlBase * /* pCaller */, const std::string &Params)
 550         {
 551                 // parse AH
 552                 bool    bNeutral= true;
 553                 OUTPOSTENUMS::TPVPSide side = OUTPOSTENUMS::UnknownPVPSide;
 554                 if(Params=="attack")
 555                 {
 556                         bNeutral= false;
 557                         side= OUTPOSTENUMS::OutpostAttacker;
 558                 }
 559                 else if(Params=="defend")
 560                 {
 561                         bNeutral= false;
 562                         side= OUTPOSTENUMS::OutpostOwner;
 563                 }
 564
 565                 // validate proposal
 566                 OutpostManager.endPvpJoinProposal(bNeutral, side);
 567         }
 568 };
 569 REGISTER_ACTION_HANDLER(CAHOutpostPVPJoin, "outpost_pvp_join");
 570
 571 // ***************************************************************************
 572 class CAHOutpostBanPlayer : public IActionHandler
 573 {
 574 public:
 575         void    execute (CCtrlBase * /* pCaller */, const std::string &sParams)
 576         {
 577                 CInterfaceManager       *pIM= CInterfaceManager::getInstance();
 578
 579                 // Ask if ok before.
 580                 pIM->validMessageBox(CInterfaceManager::QuestionIconMsg, CI18N::get("uiQConfirmOutpostBanPlayer"),
 581                         "outpost_do_ban_player", sParams, "");
 582         }
 583 };
 584 REGISTER_ACTION_HANDLER(CAHOutpostBanPlayer, "outpost_ban_player");
 585
 586 // ***************************************************************************
 587 class CAHOutpostBanGuild : public IActionHandler
 588 {
 589 public:
 590         void    execute (CCtrlBase * /* pCaller */, const std::string &sParams)
 591         {
 592                 CInterfaceManager       *pIM= CInterfaceManager::getInstance();
 593
 594                 // Ask if ok before.
 595                 pIM->validMessageBox(CInterfaceManager::QuestionIconMsg, CI18N::get("uiQConfirmOutpostBanGuild"),
 596                         "outpost_do_ban_guild", sParams, "");
 597         }
 598 };
 599 REGISTER_ACTION_HANDLER(CAHOutpostBanGuild, "outpost_ban_guild");
 600
 601 // ***************************************************************************
 602 // Used also in game_context_menu
 603 void    outpostTestUserCanBan(CCDBNodeLeaf *dbBanRight, bool &okForBanPlayer, bool &okForBanGuild)
 604 {
 605         okForBanPlayer= false;
 606         okForBanGuild= false;
 607
 608         /** A player can ban a player in a PVP outpost if:
 609          *      - The player has right to ban AND his guild attack/owns the outpost the player attacks (all this is in RIGHT_BANNISH)
 610          *      - The player and the target are in the same war of the outpost, and in same alliance.
 611          *      - The player and the target are not in same guild
 612          */
 613         if(dbBanRight && dbBanRight->getValueBool() && UserEntity)
 614         {
 615                 CEntityCL *selection = EntitiesMngr.entity(UserEntity->selection());
 616                 if(selection && selection->isPlayer())
 617                 {
 618                         // in same outpost War and Side
 619                         if( selection->getOutpostId() == UserEntity->getOutpostId() &&
 620                                 selection->getOutpostSide() == UserEntity->getOutpostSide() )
 621                         {
 622                                 // not in same guild
 623                                 if( selection->getGuildNameID() != UserEntity->getGuildNameID() )
 624                                 {
 625                                         okForBanPlayer= true;
 626                                         okForBanGuild= selection->getGuildNameID()!=0;
 627                                 }
 628                         }
 629                 }
 630         }
 631 }
 632
 633 // ***************************************************************************
 634 class CAHOutpostDoBanPlayer : public IActionHandler
 635 {
 636 public:
 637         void    execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
 638         {
 639                 CInterfaceManager       *pIM= CInterfaceManager::getInstance();
 640                 CCDBNodeLeaf    *dbBan = NLGUI::CDBManager::getInstance()->getDbProp("SERVER:CHARACTER_INFO:PVP_OUTPOST:RIGHT_TO_BANISH", false);
 641
 642                 // Re-Test if can ban the selection
 643                 bool    okForBanPlayer= false;
 644                 bool    okForBanGuild= false;
 645                 outpostTestUserCanBan(dbBan, okForBanPlayer, okForBanGuild);
 646
 647                 // if still ok to ban player
 648                 if(okForBanPlayer)
 649                 {
 650                         sendMsgToServer("OUTPOST:BANISH_PLAYER");
 651                 }
 652         }
 653 };
 654 REGISTER_ACTION_HANDLER(CAHOutpostDoBanPlayer, "outpost_do_ban_player");
 655
 656 // ***************************************************************************
 657 class CAHOutpostDoBanGuild : public IActionHandler
 658 {
 659 public:
 660         void    execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
 661         {
 662                 CInterfaceManager       *pIM= CInterfaceManager::getInstance();
 663                 CCDBNodeLeaf    *dbBan = NLGUI::CDBManager::getInstance()->getDbProp("SERVER:CHARACTER_INFO:PVP_OUTPOST:RIGHT_TO_BANISH", false);
 664
 665                 // Re-Test if can ban the selection
 666                 bool    okForBanPlayer= false;
 667                 bool    okForBanGuild= false;
 668                 outpostTestUserCanBan(dbBan, okForBanPlayer, okForBanGuild);
 669
 670                 // if still ok to ban player's guild
 671                 if(okForBanGuild)
 672                 {
 673                         sendMsgToServer("OUTPOST:BANISH_GUILD");
 674                 }
 675         }
 676 };
 677 REGISTER_ACTION_HANDLER(CAHOutpostDoBanGuild, "outpost_do_ban_guild");
 678
 679 // ***************************************************************************
 680 class CAHOutpostUpdateTimeZoneAuto : public IActionHandler
 681 {
 682 public:
 683         void    execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
 684         {
 685                 CInterfaceManager       *pIM= CInterfaceManager::getInstance();
 686                 CCDBNodeLeaf    *dbTZ = NLGUI::CDBManager::getInstance()->getDbProp("UI:SAVE:OUTPOST:TIME_ZONE", false);
 687                 if(!dbTZ)
 688                         return;
 689
 690                 // *** must update time zone, in case of user changed it during play
 691                 tzset();
 692
 693                 // *** Get the difference of time => timezone
 694                 time_t  tGmt=0, tLocal=0;
 695                 struct tm *timeTm;
 696                 // get current time
 697                 time_t ltime;
 698                 time( &ltime );
 699                 // convert into GMT time
 700                 timeTm = gmtime( &ltime );
 701                 if(timeTm)
 702                         tGmt= mktime(timeTm);
 703                 // convert into local time
 704                 timeTm = localtime( &ltime );
 705                 timeTm->tm_isdst = 0;           // reset daylight saving time flag
 706                 if(timeTm)
 707                         tLocal= mktime(timeTm);
 708
 709                 // Make the difference and hence compute the time zone
 710                 double  tzSec= difftime(tLocal, tGmt);
 711                 sint    tzHour= (sint)floor(tzSec / 3600);
 712                 clamp(tzHour, -12, 12);
 713
 714                 // set the result
 715                 dbTZ->setValue32(tzHour);
 716
 717         }
 718 };
 719 REGISTER_ACTION_HANDLER(CAHOutpostUpdateTimeZoneAuto, "outpost_update_time_zone_auto");
 720