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