ryzom/client/src/interface_v3/action_handler_move.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010-2017  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
  22
  23
  24 #include "stdpch.h"
  25
  26 using namespace std;
  27 using namespace NLMISC;
  28
  29 #include "nel/gui/action_handler.h"
  30 #include "../motion/user_controls.h"
  31 #include "../view.h"
  32 #include "../misc.h"
  33 #include "../input.h"
  34 #include "../client_cfg.h"
  35 #include "../actions_client.h"
  36 #include "../entities.h"
  37 #include "interface_manager.h"
  38 #include "action_handler_tools.h"
  39 #include "nel/gui/ctrl_base_button.h"
  40
  41 ////////////
  42 // GLOBAL //
  43 ////////////
  44 extern sint                                     CompassMode;
  45 extern class CView                      View;
  46 extern CUserControls            UserControls;
  47 extern bool                                     ShowInterface;
  48
  49
  50 /**********************************************************************************************************
  51 *                                                                                                                                                                                                                 *
  52 *                                                                               debug           handlers  actions                                                                         *
  53 *                                                                                                                                                                                                                 *
  54 ***********************************************************************************************************/
  55
  56 // ------------------------------------------------------------------------------------------------
  57 class CAHChangeCompassMode : public IActionHandler
  58 {
  59         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
  60         {
  61                 CompassMode = CompassMode ? 0:1;
  62         }
  63 };
  64 REGISTER_ACTION_HANDLER (CAHChangeCompassMode, "change_compass_mode");
  65
  66 // ------------------------------------------------------------------------------------------------
  67 class CAHSetPos : public IActionHandler
  68 {
  69         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
  70         {
  71                 UserEntity->pacsPos(View.viewPos());
  72                 UserEntity->front(View.view());
  73                 UserEntity->dir(View.view());
  74         }
  75 };
  76 REGISTER_ACTION_HANDLER (CAHSetPos, "set_pos");
  77
  78
  79 // ----------------------------------------------
  80 class CAHFrontSelection : public IActionHandler
  81 {
  82 public:
  83         virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
  84         {
  85                 if(!UserEntity)
  86                         return;
  87
  88                 // select Enemy or enemy? Never select user
  89                 uint    flags;
  90                 if(Params=="friend")
  91                         // for friend: select both dead and alive (for heal). But Select only Players (not bot)
  92                         flags= CEntityFilterFlag::NotUser | CEntityFilterFlag::Player | CEntityFilterFlag::Friend;
  93                 else
  94                         // for enemy: interesting to select only Alive entities (to chain-nuke)
  95                         // select both NonPlayer and Player (for PVP)
  96                         flags= CEntityFilterFlag::NotUser | CEntityFilterFlag::Enemy | CEntityFilterFlag::Alive;
  97
  98                 // If there is an entity selected -> Set as the Target. Cycle with last target
  99                 CEntityCL *entity = EntitiesMngr.getEntityInCamera(flags, ClientCfg.SpaceSelectionDist, UserEntity->targetSlot());
 100                 if(entity)
 101                 {
 102                         // Select this entity.
 103                         UserEntity->selection(entity->slot());
 104                         // Yoyo: not interesting: commonly Fight (use shortcut instead)
 105                         // Launch Context Menu.
 106                         /*CInterfaceManager *IM = CInterfaceManager::getInstance();
 107                         IM->launchContextMenuInGame("ui:interface:game_context_menu");*/
 108                 }
 109         }
 110 };
 111 REGISTER_ACTION_HANDLER (CAHFrontSelection, "front_selection");
 112
 113 // ------------------------------------------------------------------------------------------------
 114 class CAHMove : public IActionHandler
 115 {
 116 public:
 117         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 118         {
 119                 // Moving Break the Follow Mode
 120                 UserEntity->disableFollow();
 121                 UserEntity->moveTo(CLFECOMMON::INVALID_SLOT, 0.0, CUserEntity::None);
 122         }
 123 };
 124
 125 // ------------------------------------------------------------------------------------------------
 126 class CAHTurnLeft    : public CAHMove
 127 {
 128 };
 129 REGISTER_ACTION_HANDLER (CAHTurnLeft, "turn_left");
 130
 131 // ------------------------------------------------------------------------------------------------
 132 class CAHTurnRight   : public CAHMove
 133 {
 134 };
 135 REGISTER_ACTION_HANDLER (CAHTurnRight, "turn_right");
 136
 137 // ------------------------------------------------------------------------------------------------
 138 class CAHStrafeLeft  : public CAHMove
 139 {
 140 };
 141 REGISTER_ACTION_HANDLER (CAHStrafeLeft, "strafe_left");
 142
 143 // ------------------------------------------------------------------------------------------------
 144 class CAHStrafeRight : public CAHMove
 145 {
 146 };
 147 REGISTER_ACTION_HANDLER (CAHStrafeRight, "strafe_right");
 148
 149 // ------------------------------------------------------------------------------------------------
 150 class CAHForward     : public CAHMove
 151 {
 152 };
 153 REGISTER_ACTION_HANDLER (CAHForward, "forward");
 154
 155 // ------------------------------------------------------------------------------------------------
 156 class CAHBackward    : public CAHMove
 157 {
 158 };
 159 REGISTER_ACTION_HANDLER (CAHBackward, "backward");
 160
 161 // ------------------------------------------------------------------------------------------------
 162 class CAHToggleAutoWalk: public IActionHandler
 163 {
 164 public:
 165         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 166         {
 167         }
 168 };
 169 REGISTER_ACTION_HANDLER (CAHToggleAutoWalk, "toggle_auto_walk");
 170
 171
 172 // ------------------------------------------------------------------------------------------------
 173 class CAHToggleLight: public IActionHandler
 174 {
 175         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 176         {
 177                 UserEntity->light();
 178         }
 179 };
 180 REGISTER_ACTION_HANDLER (CAHToggleLight, "toggle_light");
 181
 182 // ------------------------------------------------------------------------------------------------
 183 class CAHFreeMouse : public IActionHandler
 184 {
 185         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 186         {
 187                 InitMouseWithCursor (!IsMouseCursorHardware ());
 188                 ClientCfg.HardwareCursor = IsMouseCursorHardware();
 189                 // if the game config window is opened, keep in sync
 190                 bool written = false;
 191                 CInterfaceManager *im = CInterfaceManager::getInstance();
 192                 if (im)
 193                 {
 194                         CInterfaceGroup *ig = dynamic_cast<CInterfaceGroup *>(CWidgetManager::getInstance()->getElementFromId("ui:interface:game_config"));
 195                         if (ig && ig->getActive())
 196                         {
 197                                 CInterfaceGroup *igHard = dynamic_cast<CInterfaceGroup *>(ig->getGroup("hard"));
 198                                 if (igHard)
 199                                 {
 200                                         CCtrlBaseButton *cbb = dynamic_cast<CCtrlBaseButton *>(igHard->getCtrl("c"));
 201                                         if (cbb)
 202                                         {
 203                                                 if(cbb->getPushed() != IsMouseCursorHardware())
 204                                                 {
 205                                                         cbb->setPushed(IsMouseCursorHardware());
 206                                                         cbb->runLeftClickAction();
 207                                                         written = true;
 208                                                 }
 209                                         }
 210                                 }
 211                         }
 212                 }
 213                 if (!written)
 214                 {
 215                         ClientCfg.writeBool("HardwareCursor", IsMouseCursorHardware());
 216                 }
 217         }
 218 };
 219 REGISTER_ACTION_HANDLER (CAHFreeMouse, "free_mouse");
 220
 221 // ------------------------------------------------------------------------------------------------
 222 class CAHToggleCamera : public IActionHandler
 223 {
 224         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 225         {
 226                 // Change the camera view
 227                 UserEntity->toggleCamera();
 228         }
 229 };
 230 REGISTER_ACTION_HANDLER (CAHToggleCamera, "toggle_camera");
 231
 232 // ------------------------------------------------------------------------------------------------
 233 class CAHTForceFP : public IActionHandler
 234 {
 235         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 236         {
 237                 // Change the camera view to first person
 238                 UserEntity->forceCameraFirstPerson();
 239         }
 240 };
 241 REGISTER_ACTION_HANDLER (CAHTForceFP, "force_camera_fp");
 242
 243 // ------------------------------------------------------------------------------------------------
 244 class CAHToggleNames : public IActionHandler
 245 {
 246 public:
 247         CAHToggleNames()
 248         {
 249                 _Count = 0;
 250         }
 251
 252         virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
 253         {
 254                 CActionsManager *pAM = &Actions;
 255                 // Key Up
 256                 if(!pAM->valide(CAction::CName("toggle_names", Params.c_str())))
 257                 {
 258                         // Toggles Names back.
 259                         if(_Count > 1)
 260                                 ClientCfg.Names = !ClientCfg.Names;
 261                         _Count = 0;
 262                 }
 263                 // Key Down
 264                 else
 265                 {
 266                         // First Time
 267                         if(_Count == 0)
 268                                 ClientCfg.Names = !ClientCfg.Names;
 269                         _Count++;
 270                 }
 271         }
 272 private:
 273         uint32 _Count;
 274 };
 275 REGISTER_ACTION_HANDLER (CAHToggleNames, "toggle_names");
 276
 277 // ------------------------------------------------------------------------------------------------
 278 class CAHRearView : public IActionHandler
 279 {
 280         virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
 281         {
 282                 static bool PreviousShowInterface = true;
 283
 284                 CActionsManager *pAM = &Actions;
 285                 // Key Down
 286                 if(pAM->valide(CAction::CName("rear_view", Params.c_str())))
 287                 {
 288                         PreviousShowInterface = ShowInterface;          // save previous show interface value
 289                         ShowInterface = false;
 290                         View.rearView(true);
 291                 }
 292                 // Key Up
 293                 else
 294                 {
 295                         ShowInterface = PreviousShowInterface;          // restore previous show interface value
 296                         View.rearView(false);
 297                 }
 298         }
 299 };
 300 REGISTER_ACTION_HANDLER (CAHRearView, "rear_view");
 301
 302 // ------------------------------------------------------------------------------------------------
 303 class CAHCameraUp : public IActionHandler
 304 {
 305 public:
 306         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 307         {
 308         }
 309 };
 310 REGISTER_ACTION_HANDLER (CAHCameraUp, "camera_up");
 311 class CAHCameraDown : public IActionHandler
 312 {
 313 public:
 314         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 315         {
 316         }
 317 };
 318 REGISTER_ACTION_HANDLER (CAHCameraDown, "camera_down");
 319 // ------------------------------------------------------------------------------------------------
 320 class CAHCameraTurnLeft : public IActionHandler
 321 {
 322 public:
 323         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 324         {
 325         }
 326 };
 327 REGISTER_ACTION_HANDLER (CAHCameraTurnLeft, "camera_turn_left");
 328
 329 class CAHCameraTurnRight : public IActionHandler
 330 {
 331 public:
 332         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 333         {
 334         }
 335 };
 336 REGISTER_ACTION_HANDLER (CAHCameraTurnRight, "camera_turn_right");
 337
 338 class CAHCameraTurnCenter : public IActionHandler
 339 {
 340 public:
 341         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 342         {
 343                 UserControls.resetSmoothCameraDeltaYaw();
 344         }
 345 };
 346 REGISTER_ACTION_HANDLER (CAHCameraTurnCenter, "camera_turn_center");
 347
 348
 349 // ------------------------------------------------------------------------------------------------
 350 // Toggle Sit / Stand, but don't change speed
 351 class CAHToggleSitStand: public IActionHandler
 352 {
 353         void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
 354         {
 355                 UserEntity->sit(!UserEntity->isSit());
 356         }
 357 };
 358 REGISTER_ACTION_HANDLER (CAHToggleSitStand, "toggle_sit_stand");
 359
 360 // Force sit, but don't change speed
 361 class CAHForceSit: public IActionHandler
 362 {
 363         void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
 364         {
 365                 if(!UserEntity->isSit())
 366                 {
 367                         // disable afk mode
 368                         UserEntity->setAFK(false);
 369
 370                         UserEntity->sit(true);
 371                 }
 372         }
 373 };
 374 REGISTER_ACTION_HANDLER (CAHForceSit, "force_sit");
 375
 376 // Force stand, but don't change speed
 377 class CAHForceStand: public IActionHandler
 378 {
 379         void execute (CCtrlBase * /* pCaller */, const std::string &/* sParams */)
 380         {
 381                 if(UserEntity->isSit())
 382                         UserEntity->sit(false);
 383         }
 384 };
 385 REGISTER_ACTION_HANDLER (CAHForceStand, "force_stand");
 386
 387
 388 // ------------------------------------------------------------------------------------------------
 389 // Toggle run/walk, but don't unsit
 390 class CAHToggleRunWalk : public IActionHandler
 391 {
 392         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 393         {
 394                 UserEntity->switchVelocity();
 395         }
 396 };
 397 REGISTER_ACTION_HANDLER (CAHToggleRunWalk, "toggle_run_walk");
 398
 399 // force walk mode, and leave sit() mode if any
 400 class CAHForceWalk : public IActionHandler
 401 {
 402         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 403         {
 404                 // swith velocity?
 405                 if(UserEntity->running())
 406                         UserEntity->switchVelocity();
 407
 408                 // unsit?
 409                 if(UserEntity->isSit())
 410                         UserEntity->sit(false);
 411
 412                 // leave afk mode?
 413                 if(UserEntity->isAFK())
 414                         UserEntity->setAFK(false);
 415         }
 416 };
 417 REGISTER_ACTION_HANDLER (CAHForceWalk, "force_walk");
 418
 419 // force run mode, and leave sit() mode if any
 420 class CAHForceRun : public IActionHandler
 421 {
 422         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 423         {
 424                 // swith velocity?
 425                 if(!UserEntity->running())
 426                         UserEntity->switchVelocity();
 427
 428                 // unsit?
 429                 if(UserEntity->isSit())
 430                         UserEntity->sit(false);
 431
 432                 // leave afk mode?
 433                 if(UserEntity->isAFK())
 434                         UserEntity->setAFK(false);
 435         }
 436 };
 437 REGISTER_ACTION_HANDLER (CAHForceRun, "force_run");
 438
 439 // ------------------------------------------------------------------------------------------------
 440 class CAHToggleDodgeParry : public IActionHandler
 441 {
 442         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 443         {
 444                 CInterfaceManager *pIM = CInterfaceManager::getInstance();
 445                 string msg;
 446                 // 0 - dodge mode
 447                 // 1 - parry mode
 448                 if (NLGUI::CDBManager::getInstance()->getDbProp("SERVER:DEFENSE:DEFENSE_MODE")->getValue32() == 0)
 449                 {
 450                         sendMsgToServer("COMBAT:PARRY");
 451                         msg = CI18N::get("msgUserModeParry");
 452                 }
 453                 else
 454                 {
 455                         sendMsgToServer("COMBAT:DODGE");
 456                         msg = CI18N::get("msgUserModeDodge");
 457                 }
 458                 // display dodge/parry mode message
 459                 string cat = getStringCategory(msg, msg);
 460                 pIM->displaySystemInfo(msg, cat);
 461         }
 462 };
 463 REGISTER_ACTION_HANDLER (CAHToggleDodgeParry, "toggle_dodge_parry");