Code/CryEngine/CryAction/ActionMap.cpp

   1 // Copyright 2001-2018 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 /*************************************************************************
   4    -------------------------------------------------------------------------
   5    $Id$
   6    $DateTime$
   7
   8    -------------------------------------------------------------------------
   9    History:
  10    - 7:9:2004   17:48 : Created by Márcio Martins
  11    - 15:9:2010  12:30 : Revised by Dean Claassen
  12
  13 *************************************************************************/
  14 #include "StdAfx.h"
  15 #include "ActionMap.h"
  16 #include "ActionMapManager.h"
  17 #include <CrySystem/IConsole.h>
  18 #include <CryCore/CryCrc32.h>
  19
  20 #define ACTIONINPUT_NAME_STR                               "name"
  21
  22 #define ACTIONINPUT_ONPRESS_STR                            "onPress"
  23 #define ACTIONINPUT_ONRELEASE_STR                          "onRelease"
  24 #define ACTIONINPUT_ONHOLD_STR                             "onHold"
  25 #define ACTIONINPUT_ALWAYS_STR                             "always"
  26
  27 #define ACTIONINPUT_CONSOLECMD_STR                         "consoleCmd"
  28 #define ACTIONINPUT_NOMODIFIERS_STR                        "noModifiers"
  29 #define ACTIONINPUT_RETRIGGERABLE_STR                      "retriggerable"
  30
  31 #define ACTIONINPUT_PRESSTRIGGERDELAY_STR                  "pressTriggerDelay"
  32 #define ACTIONINPUT_PRESSTRIGGERDELAY_REPEATOVERRIDE_STR   "pressTriggerDelayRepeatOverride"
  33 #define ACTIONINPUT_PRESSDELAYPRIORITY_STR                 "pressDelayPriority"
  34
  35 #define ACTIONINPUT_HOLDTRIGGERDELAY_STR                   "holdTriggerDelay"
  36 #define ACTIONINPUT_HOLDTRIGGERDELAY_REPEATOVERRIDE_STR    "holdTriggerDelayRepeatOverride"
  37 #define ACTIONINPUT_HOLDREPEATDELAY_STR                    "holdRepeatDelay"
  38 #define ACTIONINPUT_RELEASETRIGGERTHRESHOLD_STR            "releaseTriggerThreshold"
  39
  40 #define ACTIONINPUT_INPUTSTOBLOCK_STR                      "inputsToBlock"
  41 #define ACTIONINPUT_INPUTBLOCKTIME_STR                     "inputBlockTime"
  42 #define ACTIONINPUT_INPUTBLOCKACTIVATION_STR               "inputBlockActivation"
  43 #define ACTIONINPUT_INPUTBLOCKDEVICEINDEX_STR              "inputBlockDeviceIndex"
  44
  45 #define ACTIONINPUT_INPUTSTOBLOCK_SPECIALTYPE_CLEARALL_STR "CLEARALL"
  46
  47 #define ACTIONINPUT_USEANALOGCOMPARE_STR                   "useAnalogCompare"
  48 #define ACTIONINPUT_ANALOGCOMPAREVAL_STR                   "analogCompareVal"
  49 #define ACTIONINPUT_ANALOGCOMPAREOP_STR                    "analogCompareOp"
  50
  51 static const char* s_analogCompareOpEqualsStr = "EQUALS";
  52 static const char* s_analogCompareOpNotEqualsStr = "NOTEQUALS";
  53 static const char* s_analogCompareOpGreaterThanStr = "GREATERTHAN";
  54 static const char* s_analogCompareOpLessThanStr = "LESSTHAN";
  55
  56 //------------------------------------------------------------------------
  57 struct CryNameSorter
  58 {
  59         //------------------------------------------------------------------------
  60         bool operator()(const CCryName& lhs, const CCryName& rhs) const
  61         {
  62                 assert(lhs.c_str() != 0);
  63                 assert(rhs.c_str() != 0);
  64                 return strcmp(lhs.c_str(), rhs.c_str()) < 0;
  65         }
  66 };
  67
  68 //------------------------------------------------------------------------
  69 CActionMapAction::CActionMapAction()
  70         : m_triggeredInput("")
  71         , m_actionId("")
  72         , m_iNumRebindedInputs(0)
  73         , m_pParentActionMap(NULL)
  74 {
  75 }
  76
  77 //------------------------------------------------------------------------
  78 CActionMapAction::~CActionMapAction()
  79 {
  80         RemoveAllActionInputs();
  81 }
  82
  83 //------------------------------------------------------------------------
  84 void CActionMapAction::GetMemoryUsage(ICrySizer* pSizer) const
  85 {
  86         TActionInputs::const_iterator iter = m_actionInputs.begin();
  87         TActionInputs::const_iterator iterEnd = m_actionInputs.end();
  88
  89         for (; iter != iterEnd; ++iter)
  90         {
  91                 const SActionInput* pActionInput = *iter;
  92                 pSizer->AddObject(pActionInput->input);
  93                 pSizer->AddObject(pActionInput->defaultInput);
  94         }
  95 }
  96
  97 //------------------------------------------------------------------------
  98 bool CActionMapAction::AddActionInput(const SActionInput& actionInput, const int iByDeviceIndex)
  99 {
 100         // Double check no invalid inputs
 101         if (strcmp(actionInput.input, "") == 0)
 102         {
 103                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::AddActionInput: Can't add empty input");
 104                 return false;
 105         }
 106
 107         // Don't require to have a crc when passing in, but if has one, check it
 108         uint32 inputCRC = CCrc32::ComputeLowercase(actionInput.input);
 109         if (actionInput.inputCRC != 0)
 110         {
 111                 if (inputCRC != actionInput.inputCRC)
 112                 {
 113                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::AddActionInput: Can't add, string crc specified doesn't match actual crc");
 114                         return false;
 115                 }
 116         }
 117
 118         SActionInput* pActionInput = FindActionInput(inputCRC);
 119         if (pActionInput != NULL)
 120         {
 121                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CAction::AddActionInput::Unable to add input with input: %s, either input already exists, or possibly 2 different inputs sharing same crc value", actionInput.input.c_str());
 122                 return false;
 123         }
 124
 125         SActionInput* pNewActionInput = new SActionInput();
 126         *pNewActionInput = actionInput;
 127         pNewActionInput->input.MakeLower();
 128         pNewActionInput->defaultInput.MakeLower();
 129         pNewActionInput->inputCRC = inputCRC;
 130
 131         if (iByDeviceIndex == -1)
 132         {
 133                 m_actionInputs.push_back(pNewActionInput);
 134                 return true;
 135         }
 136         else
 137         {
 138                 int iCurrentByDeviceIndex = 0;
 139
 140                 // Find actual index
 141                 TActionInputs::iterator iter = m_actionInputs.begin();
 142                 TActionInputs::iterator iterEnd = m_actionInputs.end();
 143                 for (; iter != iterEnd; ++iter)
 144                 {
 145                         SActionInput* pContainedActionInput = *iter;
 146                         CRY_ASSERT(pContainedActionInput != NULL);
 147
 148                         if (pContainedActionInput->inputDevice == actionInput.inputDevice && iCurrentByDeviceIndex == iByDeviceIndex)
 149                         {
 150                                 m_actionInputs.insert(iter, pNewActionInput);
 151                                 return true;
 152                         }
 153                         else
 154                         {
 155                                 ++iCurrentByDeviceIndex;
 156                         }
 157                 }
 158
 159                 // Reached here so iByDeviceIndex must be incorrect
 160                 SAFE_DELETE(pNewActionInput);
 161                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CAction::AddActionInput: Failed adding input with input: %s, iByDeviceIndex: %d, is incorrect", actionInput.input.c_str(), iByDeviceIndex);
 162                 return false;
 163         }
 164 }
 165
 166 //------------------------------------------------------------------------
 167 bool CActionMapAction::RemoveActionInput(uint32 inputCRC)
 168 {
 169         TActionInputs::iterator iter = m_actionInputs.begin();
 170         TActionInputs::iterator iterEnd = m_actionInputs.end();
 171         for (; iter != iterEnd; ++iter)
 172         {
 173                 SActionInput* pActionInput = *iter;
 174                 CRY_ASSERT(pActionInput != NULL);
 175                 if (pActionInput->inputCRC == inputCRC)
 176                 {
 177                         SAFE_DELETE(pActionInput);
 178                         m_actionInputs.erase(iter);
 179                         return true;
 180                 }
 181         }
 182
 183         return false;
 184 }
 185
 186 //------------------------------------------------------------------------
 187 void CActionMapAction::RemoveAllActionInputs()
 188 {
 189         TActionInputs::iterator iter = m_actionInputs.begin();
 190         TActionInputs::iterator iterEnd = m_actionInputs.end();
 191         for (; iter != iterEnd; ++iter)
 192         {
 193                 SActionInput* pActionInput = *iter;
 194                 CRY_ASSERT(pActionInput != NULL);
 195                 SAFE_DELETE(pActionInput);
 196         }
 197         m_actionInputs.clear();
 198 }
 199
 200 //------------------------------------------------------------------------
 201 SActionInput* CActionMapAction::FindActionInput(uint32 inputCRC)
 202 {
 203         SActionInput* pFoundActionInput = NULL;
 204
 205         TActionInputs::iterator iter = m_actionInputs.begin();
 206         TActionInputs::iterator iterEnd = m_actionInputs.end();
 207         for (; iter != iterEnd; ++iter)
 208         {
 209                 SActionInput* pActionInput = *iter;
 210                 CRY_ASSERT(pActionInput != NULL);
 211                 if (pActionInput->inputCRC == inputCRC)
 212                 {
 213                         pFoundActionInput = pActionInput;
 214                         break;
 215                 }
 216         }
 217
 218         return pFoundActionInput;
 219 }
 220
 221 //------------------------------------------------------------------------
 222 const SActionInput* CActionMapAction::FindActionInput(const char* szInput) const
 223 {
 224         uint32 inputCRC = CCrc32::ComputeLowercase(szInput);
 225
 226         const SActionInput* pFoundActionInput = NULL;
 227
 228         TActionInputs::const_iterator iter = m_actionInputs.begin();
 229         TActionInputs::const_iterator iterEnd = m_actionInputs.end();
 230         for (; iter != iterEnd; ++iter)
 231         {
 232                 const SActionInput* pActionInput = *iter;
 233                 CRY_ASSERT(pActionInput != NULL);
 234                 if (pActionInput->inputCRC == inputCRC)
 235                 {
 236                         pFoundActionInput = pActionInput;
 237                         break;
 238                 }
 239         }
 240
 241         return pFoundActionInput;
 242 }
 243
 244 //------------------------------------------------------------------------
 245 SActionInput* CActionMapAction::GetActionInput(const int iIndex)
 246 {
 247         CRY_ASSERT(iIndex >= 0 && iIndex < (int)m_actionInputs.size());
 248         if (iIndex >= 0 && iIndex < (int)m_actionInputs.size())
 249         {
 250                 return m_actionInputs[iIndex];
 251         }
 252
 253         return NULL;
 254 }
 255
 256 //------------------------------------------------------------------------
 257 SActionInput* CActionMapAction::GetActionInput(const EActionInputDevice device, const int iIndexByDevice)
 258 {
 259         int iCurrentIndexByDevice = 0; // Array may not be sorted, but the index specified by iIndexByDevice means the order in which its found
 260         SActionInput* pFoundActionInput = NULL;
 261         for (int i = 0; i < m_actionInputs.size(); i++)
 262         {
 263                 SActionInput* pActionInput = m_actionInputs[i];
 264                 CRY_ASSERT(pActionInput != NULL);
 265
 266                 if (pActionInput->inputDevice == device)
 267                 {
 268                         if (iCurrentIndexByDevice == iIndexByDevice)
 269                         {
 270                                 pFoundActionInput = pActionInput;
 271                                 break;
 272                         }
 273                         else // Keep looking for next one
 274                         {
 275                                 iCurrentIndexByDevice++;
 276                         }
 277                 }
 278         }
 279
 280         return pFoundActionInput;
 281 }
 282
 283 //------------------------------------------------------------------------
 284 const SActionInput* CActionMapAction::GetActionInput(const int iIndex) const
 285 {
 286         CRY_ASSERT(iIndex >= 0 && iIndex < (int)m_actionInputs.size());
 287         if (iIndex >= 0 && iIndex < (int)m_actionInputs.size())
 288         {
 289                 return m_actionInputs[iIndex];
 290         }
 291
 292         return NULL;
 293 }
 294
 295 //------------------------------------------------------------------------
 296 const SActionInput* CActionMapAction::GetActionInput(const EActionInputDevice device, const int iIndexByDevice) const
 297 {
 298         int iCurrentIndexByDevice = 0; // Array may not be sorted, but the index specified by iIndexByDevice means the order in which its found
 299         const SActionInput* pFoundActionInput = NULL;
 300         for (int i = 0; i < m_actionInputs.size(); i++)
 301         {
 302                 const SActionInput* pActionInput = m_actionInputs[i];
 303                 CRY_ASSERT(pActionInput != NULL);
 304
 305                 if (pActionInput->inputDevice == device)
 306                 {
 307                         if (iCurrentIndexByDevice == iIndexByDevice)
 308                         {
 309                                 pFoundActionInput = pActionInput;
 310                                 break;
 311                         }
 312                         else // Keep looking for next one
 313                         {
 314                                 iCurrentIndexByDevice++;
 315                         }
 316                 }
 317         }
 318
 319         return pFoundActionInput;
 320 }
 321
 322 //------------------------------------------------------------------------
 323 SActionInput* CActionMapAction::AddAndGetActionInput(const SActionInput& actionInput)
 324 {
 325         // Don't require to have a crc when passing in, but if has one, check it
 326         uint32 inputCRC = CCrc32::ComputeLowercase(actionInput.input);
 327         if (actionInput.inputCRC != 0)
 328         {
 329                 if (inputCRC != actionInput.inputCRC)
 330                 {
 331                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::AddAndGetActionInput: Can't add, string crc specified doesn't match actual crc");
 332                         return NULL;
 333                 }
 334         }
 335
 336         SActionInput* pActionInput = FindActionInput(inputCRC);
 337         if (pActionInput != NULL)
 338         {
 339                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CAction::AddAndGetActionInput::Unable to add input with input: %s, already exists", actionInput.input.c_str());
 340                 return NULL;
 341         }
 342         SActionInput* pNewActionInput = new SActionInput();
 343         *pNewActionInput = actionInput;
 344         pNewActionInput->input.MakeLower();
 345         pNewActionInput->defaultInput.MakeLower();
 346         pNewActionInput->inputCRC = inputCRC;
 347         m_actionInputs.push_back(pNewActionInput);
 348
 349         return pNewActionInput;
 350 }
 351
 352 //------------------------------------------------------------------------
 353 CActionMap::CActionMap(CActionMapManager* pActionMapManager, const char* name)
 354         : m_pActionMapManager(pActionMapManager),
 355         m_enabled(!stricmp(name, "default")),
 356         m_listenerId(0),
 357         m_actionMapListeners(2),
 358         m_flownodesListeners(2),
 359         m_name(name),
 360         m_iNumRebindedInputs(0)
 361 {
 362 }
 363
 364 //------------------------------------------------------------------------
 365 CActionMap::~CActionMap()
 366 {
 367         Clear();
 368 }
 369
 370 //------------------------------------------------------------------------
 371 void CActionMap::Release()
 372 {
 373         m_pActionMapManager->RemoveActionMap(m_name);
 374 };
 375
 376 //------------------------------------------------------------------------
 377 void CActionMap::Clear()
 378 {
 379         m_pActionMapManager->RemoveBind(this);
 380         m_actions.clear();
 381         SetNumRebindedInputs(0);
 382 }
 383
 384 //------------------------------------------------------------------------
 385 bool CActionMap::CreateAction(const ActionId& actionId)
 386 {
 387         TActionMap::iterator iter = m_actions.find(actionId);
 388         if (iter != m_actions.end())
 389         {
 390                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::CreateAction: Unable to create action, %s already exists", actionId.c_str());
 391                 return false;
 392         }
 393
 394         CActionMapAction action;
 395         action.SetActionId(actionId);
 396         action.SetParentActionMap(this);
 397
 398         m_actions[actionId] = action;
 399
 400         return true;
 401 }
 402
 403 //------------------------------------------------------------------------
 404 bool CActionMap::RemoveAction(const ActionId& actionId)
 405 {
 406         TActionMap::iterator iter = m_actions.find(actionId);
 407         if (iter == m_actions.end())
 408         {
 409                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::RemoveAction: Failed to find action: %s", actionId.c_str());
 410                 return false;
 411         }
 412
 413         CActionMapAction& action = iter->second;
 414         m_pActionMapManager->RemoveBind(&action);
 415
 416         // Update new rebind count
 417         int newRebindCount = GetNumRebindedInputs();
 418
 419         int numActionInputs = action.GetNumActionInputs();
 420         for (int i = 0; i < numActionInputs; ++i)
 421         {
 422                 SActionInput* pActionInput = action.GetActionInput(i);
 423                 CRY_ASSERT(pActionInput != NULL);
 424
 425                 if (pActionInput->input != pActionInput->defaultInput)
 426                 {
 427                         --newRebindCount;
 428                 }
 429         }
 430
 431         if (newRebindCount != GetNumRebindedInputs())
 432         {
 433                 SetNumRebindedInputs(newRebindCount);
 434         }
 435
 436         m_actions.erase(iter);
 437
 438         return true;
 439 }
 440
 441 //------------------------------------------------------------------------
 442 bool CActionMap::AddActionInput(const ActionId& actionId, const SActionInput& actionInput, const int iByDeviceIndex)
 443 {
 444         CActionMapAction* pAction = NULL;
 445
 446         TActionMap::iterator iter = m_actions.find(actionId);
 447         if (iter == m_actions.end()) // Don't have an action, so create one to hold the input
 448         {
 449                 pAction = CreateAndGetAction(actionId);
 450                 CRY_ASSERT(pAction != NULL);
 451                 if (!pAction)
 452                 {
 453                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::AddActionInput: Failed to create action: %s", actionId.c_str());
 454                         return false;
 455                 }
 456         }
 457         else
 458         {
 459                 pAction = &iter->second;
 460                 CRY_ASSERT(pAction != NULL);
 461         }
 462
 463         return pAction->AddActionInput(actionInput, iByDeviceIndex);
 464 }
 465
 466 //------------------------------------------------------------------------
 467 bool CActionMap::AddAndBindActionInput(const ActionId& actionId, const SActionInput& actionInput)
 468 {
 469         CActionMapAction* pAction = NULL;
 470         TActionMap::iterator iAction = m_actions.find(actionId);
 471         if (iAction == m_actions.end())
 472         {
 473                 pAction = CreateAndGetAction(actionId);
 474                 CRY_ASSERT(pAction != NULL);
 475                 if (pAction == NULL)
 476                 {
 477                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::AddAndBindActionInput: Failed to create action: %s", actionId.c_str());
 478                         return false;
 479                 }
 480         }
 481         else
 482         {
 483                 pAction = &iAction->second;
 484                 CRY_ASSERT(pAction != NULL);
 485         }
 486         SActionInput* pNewActionInput = pAction->AddAndGetActionInput(actionInput);
 487         if (pNewActionInput != NULL)
 488         {
 489                 return m_pActionMapManager->AddBind(this, pAction, pNewActionInput);
 490         }
 491         else
 492         {
 493                 return false;
 494         }
 495 }
 496
 497 //------------------------------------------------------------------------
 498 bool CActionMap::RemoveActionInput(const ActionId& actionId, const char* szInput)
 499 {
 500         TActionMap::iterator iter = m_actions.find(actionId);
 501         if (iter == m_actions.end())
 502         {
 503                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::RemoveActionInput: Failed to find action: %s", actionId.c_str());
 504                 return false;
 505         }
 506
 507         CActionMapAction& action = iter->second;
 508
 509         uint32 inputCRC = CCrc32::ComputeLowercase(szInput);
 510
 511         SActionInput* pActionInput = action.FindActionInput(inputCRC);
 512         if (pActionInput == NULL)
 513         {
 514                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::RemoveActionInput: Failed to find action input for input: %s", szInput);
 515                 return false;
 516         }
 517
 518         bool bResult = m_pActionMapManager->RemoveBind(this, &action, pActionInput);
 519         if (!bResult)
 520         {
 521                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::RemoveActionInput: Failed to remove binding for action input with input: %s", szInput);
 522                 return false;
 523         }
 524
 525         return action.RemoveActionInput(inputCRC);
 526 }
 527
 528 //------------------------------------------------------------------------
 529 bool CActionMap::ReBindActionInput(const ActionId& actionId, const char* szCurrentInput, const char* szNewInput)
 530 {
 531         TActionMap::iterator iter = m_actions.find(actionId);
 532         if (iter != m_actions.end())
 533         {
 534                 CActionMapAction& action = iter->second;
 535                 return ReBindActionInput(&action, szCurrentInput, szNewInput);
 536         }
 537
 538         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::ReBindActionInput: Unable to rebind action, %s, doesn't exist", actionId.c_str());
 539         return false;
 540 }
 541
 542 //------------------------------------------------------------------------
 543 bool CActionMap::ReBindActionInput(const ActionId& actionId,
 544                                    const char* szNewInput,
 545                                    const EActionInputDevice device,
 546                                    const int iByDeviceIndex)
 547 {
 548         TActionMap::iterator iter = m_actions.find(actionId);
 549         if (iter == m_actions.end())
 550         {
 551                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::ReBindActionInput: Can't find action: %s", actionId.c_str());
 552                 return false;
 553         }
 554
 555         CActionMapAction& action = iter->second;
 556         return ReBindActionInput(&action, szNewInput, device, iByDeviceIndex);
 557 }
 558
 559 //------------------------------------------------------------------------
 560 CActionMapAction* CActionMap::CreateAndGetAction(const ActionId& actionId)
 561 {
 562         TActionMap::iterator iter = m_actions.find(actionId);
 563         if (iter != m_actions.end())
 564         {
 565                 return NULL;
 566         }
 567
 568         CActionMapAction action;
 569         action.SetActionId(actionId);
 570         action.SetParentActionMap(this);
 571
 572         m_actions[actionId] = action;
 573
 574         return &m_actions[actionId];
 575 }
 576
 577 //------------------------------------------------------------------------
 578 bool CActionMap::AddAndBindActionInput(CActionMapAction* pAction, const SActionInput& actionInput)
 579 {
 580         CRY_ASSERT(pAction != NULL);
 581         if (!pAction)
 582                 return false;
 583
 584         SActionInput* pAddedActionInput = pAction->AddAndGetActionInput(actionInput);
 585         if (!pAddedActionInput)
 586         {
 587                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::AddAndBindActionInput: Failed adding actioninput for input: %s", actionInput.input.c_str());
 588                 return false;
 589         }
 590
 591         bool bResult = m_pActionMapManager->AddBind(this, pAction, pAddedActionInput);
 592         if (!bResult)
 593         {
 594                 pAction->RemoveActionInput(pAddedActionInput->inputCRC);
 595                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::AddAndBindActionInput: Failed binding actioninput");
 596                 return false;
 597         }
 598
 599         return true;
 600 }
 601
 602 //------------------------------------------------------------------------
 603 bool CActionMap::ReBindActionInput(CActionMapAction* pAction, const char* szCurrentInput, const char* szNewInput)
 604 {
 605         uint32 inputCRC = CCrc32::ComputeLowercase(szCurrentInput);
 606
 607         SActionInput* pActionInput = pAction->FindActionInput(inputCRC);
 608         if (!pActionInput)
 609         {
 610                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::ReBindActionInput: Can't find input: %s for action: %s", szCurrentInput, pAction->GetActionId().c_str());
 611                 return false;
 612         }
 613
 614         return ReBindActionInput(pAction, *pActionInput, szNewInput);
 615 }
 616
 617 //------------------------------------------------------------------------
 618 bool CActionMap::ReBindActionInput(CActionMapAction* pAction, SActionInput& actionInput, const char* szNewInput)
 619 {
 620         CRY_ASSERT(pAction != NULL);
 621
 622         if (actionInput.input == szNewInput) // Rebinding to same input
 623                 return false;
 624
 625         if (m_pActionMapManager->HasBind(this, pAction, &actionInput)) // Might not be binded if cleared
 626         {
 627                 bool bResult = m_pActionMapManager->RemoveBind(this, pAction, &actionInput);
 628                 if (!bResult)
 629                 {
 630                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::ReBindActionInput: Failed removing bind for input: %s for action: %s", actionInput.input.c_str(), pAction->GetActionId().c_str());
 631                         return false;
 632                 }
 633         }
 634
 635         actionInput.input = szNewInput;
 636
 637         // Possible to assign empty to clear the binding
 638         if (szNewInput != NULL && strcmp(szNewInput, "") != 0)
 639         {
 640                 actionInput.inputCRC = CCrc32::ComputeLowercase(szNewInput);
 641
 642                 bool bResult = m_pActionMapManager->AddBind(this, pAction, &actionInput);
 643                 if (!bResult)
 644                 {
 645                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::ReBindActionInput: Failed removing bind for input: %s for action: %s", actionInput.input.c_str(), pAction->GetActionId().c_str());
 646                         return false;
 647                 }
 648         }
 649
 650         // If input now equals the default, nolonger needs the mark from the previous rebind
 651         if (actionInput.input == actionInput.defaultInput)
 652         {
 653                 SetNumRebindedInputs(GetNumRebindedInputs() - 1);
 654                 pAction->SetNumRebindedInputs(pAction->GetNumRebindedInputs() - 1);
 655         }
 656         else // Remember this rebind
 657         {
 658                 SetNumRebindedInputs(GetNumRebindedInputs() + 1);
 659                 pAction->SetNumRebindedInputs(pAction->GetNumRebindedInputs() + 1);
 660         }
 661
 662         return true;
 663 }
 664
 665 //------------------------------------------------------------------------
 666 bool CActionMap::ReBindActionInput(CActionMapAction* pAction,
 667                                    const char* szNewInput,
 668                                    const EActionInputDevice device,
 669                                    const int iByDeviceIndex)
 670 {
 671
 672         SActionInput* pActionInput = pAction->GetActionInput(device, iByDeviceIndex);
 673         if (!pActionInput)
 674         {
 675                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::ReBindActionInput: Can't get input by index: %d for action: %s", iByDeviceIndex, pAction->GetActionId().c_str());
 676                 return false;
 677         }
 678
 679         if (pActionInput->input == szNewInput) // Rebinding to same input
 680                 return false;
 681
 682         if (m_pActionMapManager->HasBind(this, pAction, pActionInput)) // Might not be binded if cleared
 683         {
 684                 bool bResult = m_pActionMapManager->RemoveBind(this, pAction, pActionInput);
 685                 if (!bResult)
 686                 {
 687                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::ReBindActionInput: Failed removing bind for input: %s for action: %s", pActionInput->input.c_str(), pAction->GetActionId().c_str());
 688                         return false;
 689                 }
 690         }
 691
 692         pActionInput->input = szNewInput;
 693
 694         // Possible to assign empty to clear the binding
 695         if (szNewInput != NULL && strcmp(szNewInput, "") != 0)
 696         {
 697                 pActionInput->inputCRC = CCrc32::ComputeLowercase(szNewInput);
 698
 699                 bool bResult = m_pActionMapManager->AddBind(this, pAction, pActionInput);
 700                 if (!bResult)
 701                 {
 702                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::ReBindActionInput: Failed removing bind for input: %s for action: %s", pActionInput->input.c_str(), pAction->GetActionId().c_str());
 703                         return false;
 704                 }
 705         }
 706         else
 707         {
 708                 pActionInput->inputCRC = 0;
 709         }
 710
 711         // If input now equals the default, nolonger needs the mark from the previous rebind
 712         if (pActionInput->input == pActionInput->defaultInput)
 713         {
 714                 SetNumRebindedInputs(GetNumRebindedInputs() - 1);
 715                 pAction->SetNumRebindedInputs(pAction->GetNumRebindedInputs() - 1);
 716         }
 717         else // Remember this rebind
 718         {
 719                 SetNumRebindedInputs(GetNumRebindedInputs() + 1);
 720                 pAction->SetNumRebindedInputs(pAction->GetNumRebindedInputs() + 1);
 721         }
 722
 723         return true;
 724
 725 }
 726
 727 //------------------------------------------------------------------------
 728 void CActionMap::SetActionListener(EntityId id)
 729 {
 730         m_listenerId = id;
 731 }
 732
 733 //------------------------------------------------------------------------
 734 EntityId CActionMap::GetActionListener() const
 735 {
 736         return m_listenerId;
 737 }
 738
 739 //------------------------------------------------------------------------
 740 bool CActionMap::Reset()
 741 {
 742         m_enabled = !stricmp(GetName(), "default");
 743
 744         for (TActionMap::iterator it = m_actions.begin(); it != m_actions.end(); ++it)
 745         {
 746                 CActionMapAction& action = it->second;
 747
 748                 const int numInputs = action.GetNumActionInputs();
 749                 for (int i = 0; i < numInputs; i++)
 750                 {
 751                         SActionInput* pActionInput = action.GetActionInput(i);
 752                         CRY_ASSERT(pActionInput != NULL);
 753
 754                         if (pActionInput->input == pActionInput->defaultInput) // Input is already default
 755                                 continue;
 756
 757                         if (!ReBindActionInput(&action, *pActionInput, pActionInput->defaultInput))
 758                         {
 759                                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::Reset: Failed resetting binding to default input in action: %s", action.GetActionId().c_str());
 760                                 return false;
 761                         }
 762                 }
 763         }
 764
 765         return true;
 766 }
 767
 768 //------------------------------------------------------------------------
 769 const IActionMapAction* CActionMap::GetAction(const ActionId& actionId) const
 770 {
 771         TActionMap::const_iterator actionIter = m_actions.find(actionId);
 772         if (actionIter == m_actions.end())
 773                 return NULL;
 774
 775         const CActionMapAction& action = actionIter->second;
 776
 777         return &action;
 778 }
 779
 780 //------------------------------------------------------------------------
 781 IActionMapAction* CActionMap::GetAction(const ActionId& actionId)
 782 {
 783         TActionMap::iterator actionIter = m_actions.find(actionId);
 784         if (actionIter == m_actions.end())
 785                 return NULL;
 786
 787         IActionMapAction& action = actionIter->second;
 788
 789         return &action;
 790 }
 791
 792 //------------------------------------------------------------------------
 793 bool CActionMap::CanProcessInput(const SInputEvent& inputEvent, CActionMap* pActionMap, CActionMapAction* pAction, SActionInput* pActionInput)
 794 {
 795         CRY_PROFILE_FUNCTION(PROFILE_ACTION);
 796         bool bRes = false;
 797
 798         float fCurrTime = gEnv->pTimer->GetCurrTime();
 799         IGameFramework* pGameFramework = gEnv->pGameFramework;
 800         if (pGameFramework && pGameFramework->IsGamePaused())
 801         {
 802                 fCurrTime = gEnv->pTimer->GetCurrTime(ITimer::ETIMER_UI);
 803         }
 804
 805         if (m_enabled)
 806         {
 807                 // Normal buttons + keys send a press, down, release events
 808                 // Analog events only send changed
 809                 // So deal with these totally differently
 810                 if (pActionInput->activationMode & eAAM_AnalogCompare)
 811                 {
 812                         switch (pActionInput->analogCompareOp) // Check if fulfills analog condition
 813                         {
 814                         case eAACO_Equals:
 815                                 {
 816                                         if (fabs(inputEvent.value - pActionInput->fAnalogCompareVal) < FLT_EPSILON)
 817                                         {
 818                                                 bRes = true;
 819                                         }
 820                                 }
 821                                 break;
 822                         case eAACO_NotEquals:
 823                                 {
 824                                         if (fabs(inputEvent.value - pActionInput->fAnalogCompareVal) >= FLT_EPSILON)
 825                                         {
 826                                                 bRes = true;
 827                                         }
 828                                 }
 829                                 break;
 830                         case eAACO_GreaterThan:
 831                                 {
 832                                         if (inputEvent.value > pActionInput->fAnalogCompareVal)
 833                                         {
 834                                                 bRes = true;
 835                                         }
 836                                 }
 837                                 break;
 838                         case eAACO_LessThan:
 839                                 {
 840                                         if (inputEvent.value < pActionInput->fAnalogCompareVal)
 841                                         {
 842                                                 bRes = true;
 843                                         }
 844                                 }
 845                                 break;
 846                         }
 847
 848                         if (bRes)
 849                         {
 850                                 // Since analog inputs dont have the concept of being down, create a refire timer to simulate hold
 851                                 // and remove this when analog condition nolonger fulfilled
 852                                 if (!m_pActionMapManager->IsCurrentlyRefiringInput()) // Input event is from refire, dont try to refire a refired event
 853                                 {
 854                                         m_pActionMapManager->UpdateRefireData(inputEvent, pActionMap, pAction, pActionInput);
 855                                 }
 856
 857                                 if (pActionInput->bAnalogConditionFulfilled != true)
 858                                 {
 859                                         pActionInput->fPressedTime = fCurrTime;
 860                                         pActionInput->fLastRepeatTime = fCurrTime;
 861                                         pActionInput->bHoldTriggerFired = false;
 862                                         pActionInput->fCurrentHoldValue = 0.f;
 863                                         pActionInput->bAnalogConditionFulfilled = true;
 864                                         pActionInput->currentState = eIS_Pressed;
 865                                 }
 866                                 else if (pActionInput->bHoldTriggerFired)
 867                                 {
 868                                         pActionInput->currentState = eIS_Changed;
 869                                 }
 870
 871                                 // Although condition is true, result value can be set false again if hold timer conditions aren't true
 872                                 // Only check if action should be processed here
 873                                 bRes = IsActionInputTriggered(inputEvent, pActionMap, pAction, pActionInput);
 874                         }
 875                         else // Didn't fulfill analog condition
 876                         {
 877                                 if (!m_pActionMapManager->IsCurrentlyRefiringInput() && pActionInput->bAnalogConditionFulfilled != false)
 878                                 {
 879                                         pActionInput->bAnalogConditionFulfilled = false;
 880                                         m_pActionMapManager->RemoveRefireData(pActionMap, pAction, pActionInput);
 881                                 }
 882                                 pActionInput->fCurrentHoldValue = 0.f;
 883                                 pActionInput->currentState = eIS_Released;
 884                         }
 885                 }
 886                 else if (inputEvent.state == eIS_Pressed)
 887                 {
 888                         pActionInput->fPressedTime = fCurrTime;
 889
 890                         if (pActionInput->activationMode & eAAM_OnHold) // Needed for hold
 891                         {
 892                                 pActionInput->fLastRepeatTime = fCurrTime;
 893                                 if (pActionInput->fHoldTriggerDelay > 0.f)
 894                                 {
 895                                         pActionInput->bHoldTriggerFired = false;
 896                                 }
 897                                 else // Hold trigger delay is immediate, same with press event, so dont fire twice
 898                                 {
 899                                         pActionInput->bHoldTriggerFired = true;
 900                                 }
 901
 902                                 pActionInput->fCurrentHoldValue = 0.f;
 903                         }
 904
 905                         // Check if the action should be processed
 906                         bRes = IsActionInputTriggered(inputEvent, pActionMap, pAction, pActionInput);
 907                 }
 908                 else // All other cases
 909                 {
 910                         // Check if the action should be processed
 911                         bRes = IsActionInputTriggered(inputEvent, pActionMap, pAction, pActionInput);
 912                 }
 913
 914                 // Remember the triggered input
 915
 916                 // Change action's current state
 917                 if (!bRes)
 918                 {
 919                         if (inputEvent.state == eIS_Down && pActionInput->currentState == eIS_Pressed && (pActionInput->activationMode & eAAM_OnRelease))
 920                                 pActionInput->currentState = eIS_Pressed;
 921                         else
 922                                 pActionInput->currentState = eIS_Unknown;
 923                 }
 924                 else if (inputEvent.state == eIS_Changed && !(pActionInput->activationMode & eAAM_AnalogCompare))
 925                 {
 926                         pActionInput->currentState = eIS_Changed;
 927                 }
 928                 else if (inputEvent.state == eIS_Down)
 929                 {
 930                         pActionInput->currentState = eIS_Down;
 931                 }
 932                 else if (pActionInput->activationMode & (eAAM_OnPress | eAAM_OnRelease))
 933                 {
 934                         if (inputEvent.state == eIS_Released || inputEvent.state == eIS_Pressed)
 935                                 pActionInput->currentState = inputEvent.state;
 936                 }
 937         }
 938
 939         return bRes;
 940 }
 941
 942 //------------------------------------------------------------------------
 943 bool CActionMap::IsActionInputTriggered(const SInputEvent& inputEvent, CActionMap* pActionMap, CActionMapAction* pAction, SActionInput* pActionInput) const
 944 {
 945         bool bRes = false;
 946
 947         if ((inputEvent.modifiers & eMM_Modifiers) &&
 948             (pActionInput->activationMode & eAAM_NoModifiers))
 949         {
 950                 return bRes;
 951         }
 952
 953         float fCurrTime = gEnv->pTimer->GetCurrTime();
 954         IGameFramework* pGameFramework = gEnv->pGameFramework;
 955         if (pGameFramework && pGameFramework->IsGamePaused())
 956         {
 957                 fCurrTime = gEnv->pTimer->GetCurrTime(ITimer::ETIMER_UI);
 958         }
 959
 960         // currentMode -> bit flag based on key state needed for trigger, and actual key state
 961         // Special handling for certain types of logic
 962         int currentMode = pActionInput->activationMode & inputEvent.state;
 963         const float fTimePressed = fCurrTime - pActionInput->fPressedTime;
 964         const bool bJustPressed = fabs(fTimePressed) < FLT_EPSILON;
 965
 966         if ((inputEvent.state == eIS_Down) && (pActionInput->activationMode & eAAM_OnHold))
 967         {
 968                 if (bJustPressed)
 969                 {
 970                         return bRes; // When holding, a press event is handled and immediately on same time frame a hold event is passed in, ignore it
 971                 }
 972                 else
 973                 {
 974                         currentMode = eAAM_Always; // Held events aren't checked in the above line, always allow them
 975                 }
 976         }
 977         else if (inputEvent.state == eIS_Changed) // Analog events aren't checked in the above line, always allow them
 978         {
 979                 if (bJustPressed && ((pActionInput->activationMode & eAAM_OnPress) == 0)) // This is a press from analog event, but input doesn't handle press, ignore
 980                 {
 981                         return bRes;
 982                 }
 983
 984                 currentMode = eAAM_Always;
 985         }
 986         else if (inputEvent.state == eIS_Released)
 987         {
 988                 pActionInput->fCurrentHoldValue = 0.f;
 989
 990                 //ignore if we have a release threshold and it's been exceeded
 991                 if (pActionInput->fReleaseTriggerThreshold >= 0.0f && fTimePressed >= pActionInput->fReleaseTriggerThreshold)
 992                 {
 993                         return bRes;
 994                 }
 995         }
 996
 997         // Get blocking type based on how the action was triggered
 998         if (currentMode)
 999         {
1000                 // Support initial hold trigger delay and repeating
1001                 if ((pActionInput->activationMode & eAAM_OnHold) &&
1002                     (inputEvent.state == eIS_Down || (inputEvent.state == eIS_Changed && bJustPressed == false)))   // Down is for digital controls, changed is for analog (For analog, won't reach here if analog condition is false, only for analog hold, press will go below like normal press)
1003                 {
1004                         if (pActionInput->bHoldTriggerFired) // Initial hold trigger already fired
1005                         {
1006                                 if (fCurrTime < pActionInput->fLastRepeatTime)
1007                                 {
1008                                         pActionInput->fLastRepeatTime = fCurrTime;
1009                                 }
1010
1011                                 if (pActionInput->fHoldRepeatDelay != -1.0f && fCurrTime - pActionInput->fLastRepeatTime >= pActionInput->fHoldRepeatDelay) // fHoldRepeatDelay of -1.0f means no repeat
1012                                 {
1013                                         pActionInput->fLastRepeatTime = fCurrTime;
1014                                         bRes = true;
1015                                 }
1016                         }
1017                         else
1018                         {
1019                                 const bool bIsCurrentKey = (m_pActionMapManager->GetIncomingInputKeyID() == inputEvent.keyId);
1020                                 // Support overriding hold trigger timer if repeating same input
1021                                 if ((m_pActionMapManager->IsRepeatedInputHoldTriggerFired()) &&     // Could have been interrupted by another held key
1022                                     (bIsCurrentKey) &&                                              // Need to check since could have multiple held keys
1023                                     (pActionInput->fHoldTriggerDelayRepeatOverride >= FLT_EPSILON)) // Default is -1.0f which won't activate this
1024                                 {
1025                                         if (fTimePressed >= pActionInput->fHoldTriggerDelayRepeatOverride)
1026                                         {
1027                                                 pActionInput->bHoldTriggerFired = true;
1028                                                 pActionInput->fCurrentHoldValue = 1.f;
1029                                                 pActionInput->fLastRepeatTime = fCurrTime;
1030                                                 bRes = true;
1031                                         }
1032                                 }
1033                                 else if (fTimePressed >= pActionInput->fHoldTriggerDelay)
1034                                 {
1035                                         pActionInput->bHoldTriggerFired = true;
1036                                         pActionInput->fCurrentHoldValue = 1.f;
1037                                         pActionInput->fLastRepeatTime = fCurrTime;
1038                                         if (m_pActionMapManager->IsIncomingInputRepeated() && bIsCurrentKey) // Need to check since could have multiple held keys
1039                                         {
1040                                                 m_pActionMapManager->SetRepeatedInputHoldTriggerFired(true);
1041                                         }
1042                                         bRes = true;
1043                                 }
1044                                 else
1045                                 {
1046                                         if (pActionInput->fHoldTriggerDelay > 0.f)
1047                                         {
1048                                                 pActionInput->fCurrentHoldValue = (fTimePressed / pActionInput->fHoldTriggerDelay);
1049                                         }
1050                                         else
1051                                         {
1052                                                 pActionInput->fCurrentHoldValue = 0.f;
1053                                         }
1054                                 }
1055                         }
1056                 }
1057                 else if ((inputEvent.state == eIS_Pressed) &&
1058                          (pActionInput->fPressTriggerDelay >= FLT_EPSILON) &&  // Handle delayed press situation
1059                          (!m_pActionMapManager->IsCurrentlyRefiringInput()))   // Input event is from refire, dont try to refire a refired event
1060                 {
1061                         if ((m_pActionMapManager->IsIncomingInputRepeated()) &&
1062                             (m_pActionMapManager->GetIncomingInputKeyID() == inputEvent.keyId) && // Repeated same input, allow override if is one
1063                             (pActionInput->fPressTriggerDelayRepeatOverride >= FLT_EPSILON))      // Default is -1.0f which won't activate this
1064                         {
1065                                 // Remove delayed press fire
1066                                 m_pActionMapManager->RemoveRefireData(pActionMap, pAction, pActionInput);
1067
1068                                 bRes = true;
1069                         }
1070                         else // Not repeated key, must wait for delay before firing
1071                         {
1072                                 // Check press delay priority, if greater or equal to current, override
1073                                 int currentHighestDelayPriority = m_pActionMapManager->GetHighestPressDelayPriority();
1074                                 if (pActionInput->iPressDelayPriority >= currentHighestDelayPriority)
1075                                 {
1076                                         m_pActionMapManager->RemoveAllDelayedPressRefireData();
1077                                         m_pActionMapManager->UpdateRefireData(inputEvent, pActionMap, pAction, pActionInput); // Will fire again after delay
1078                                 }
1079                                 bRes = false;
1080                         }
1081                 }
1082                 else if ((inputEvent.state == eIS_Released) &&
1083                          (pActionInput->fPressTriggerDelay >= FLT_EPSILON) &&  // Handle delayed press situation
1084                          (!m_pActionMapManager->IsCurrentlyRefiringInput()))   // Input event is from refire, dont try to refire a refired event
1085                 {
1086                         if (fTimePressed - pActionInput->fPressTriggerDelay < FLT_EPSILON) // Press delay hasn't fired yet, release should be fired right after delayed press
1087                         {
1088                                 m_pActionMapManager->SetRefireDataDelayedPressNeedsRelease(inputEvent, pActionMap, pAction, pActionInput, true);
1089                                 bRes = false;
1090                         }
1091                         else // Ok to fire release since delayed press already fired
1092                         {
1093                                 bRes = true;
1094                         }
1095                 }
1096                 else // Not held
1097                 {
1098                         bRes = true;
1099                 }
1100         }
1101
1102         return bRes;
1103 }
1104
1105 //------------------------------------------------------------------------
1106 void CActionMap::InputProcessed()
1107 {
1108         IActionListener* pEntityListener = NULL;
1109
1110         if (IEntity* pEntity = gEnv->pEntitySystem->GetEntity(m_listenerId))
1111         {
1112                 if (IGameObject* pGameObject = static_cast<IGameObject*>(pEntity->GetProxy(ENTITY_PROXY_USER)))
1113                 {
1114                         pEntityListener = pGameObject;
1115                 }
1116         }
1117
1118         if (pEntityListener)
1119                 pEntityListener->AfterAction();
1120
1121         for (TActionMapListeners::Notifier notify(m_actionMapListeners); notify.IsValid(); notify.Next())
1122         {
1123                 notify->AfterAction();
1124         }
1125 }
1126
1127 //------------------------------------------------------------------------
1128 void CActionMap::ReleaseActionsIfActive()
1129 {
1130         TActionMap::iterator it = m_actions.begin();
1131         TActionMap::iterator end = m_actions.end();
1132         for (; it != end; ++it)
1133         {
1134                 CActionMapAction& action = it->second;
1135                 ReleaseActionIfActiveInternal(action);
1136         }
1137 }
1138
1139 //------------------------------------------------------------------------
1140 void CActionMap::ReleaseFilteredActions()
1141 {
1142         IActionListener* pEntityListener = NULL;
1143
1144         if (IEntity* pEntity = gEnv->pEntitySystem->GetEntity(m_listenerId))
1145         {
1146                 if (IGameObject* pGameObject = static_cast<IGameObject*>(pEntity->GetProxy(ENTITY_PROXY_USER)))
1147                 {
1148                         pEntityListener = pGameObject;
1149                 }
1150         }
1151
1152         IActionListener* pListener = pEntityListener;
1153
1154         for (TActionMap::iterator it = m_actions.begin(), eit = m_actions.end(); it != eit; ++it)
1155         {
1156                 CActionMapAction& action = it->second;
1157
1158                 int iNumActionInputs = action.GetNumActionInputs();
1159                 for (int i = 0; i < iNumActionInputs; ++i)
1160                 {
1161                         SActionInput* pActionInput = action.GetActionInput(i);
1162                         CRY_ASSERT(pActionInput != NULL);
1163
1164                         bool isPressedOrDown = (pActionInput->currentState == eIS_Pressed) || (pActionInput->currentState == eIS_Down);
1165                         bool isChanged = pActionInput->currentState == eIS_Changed;
1166
1167                         if ((!isPressedOrDown && !isChanged) || !m_pActionMapManager->ActionFiltered(it->first))
1168                                 continue;
1169
1170                         pActionInput->fCurrentHoldValue = 0.f;
1171
1172                         int currentMode = pActionInput->activationMode & eIS_Released;
1173                         if (currentMode || isChanged)
1174                         {
1175                                 if (pListener)
1176                                 {
1177                                         pListener->OnAction(it->first, currentMode, 0);
1178                                 }
1179
1180                                 const TActionListeners& extraActionListeners = m_pActionMapManager->GetExtraActionListeners();
1181                                 for (TActionListeners::const_iterator extraListener = extraActionListeners.begin(); extraListener != extraActionListeners.end(); ++extraListener)
1182                                         (*extraListener)->OnAction(it->first, currentMode, 0);
1183
1184                                 NotifyExtraActionListeners(it->first, currentMode, 0);
1185                         }
1186                 }
1187         }
1188 }
1189
1190 //------------------------------------------------------------------------
1191 void CActionMap::AddExtraActionListener(IActionListener* pExtraActionListener)
1192 {
1193         m_actionMapListeners.Add(pExtraActionListener);
1194 }
1195
1196 //------------------------------------------------------------------------
1197 void CActionMap::RemoveExtraActionListener(IActionListener* pExtraActionListener)
1198 {
1199         m_actionMapListeners.Remove(pExtraActionListener);
1200 }
1201
1202 //------------------------------------------------------------------------
1203 void CActionMap::NotifyFlowNodeActionListeners(const ActionId& action, int currentState, float value)
1204 {
1205         for (TActionMapListeners::Notifier notify(m_flownodesListeners); notify.IsValid(); notify.Next())
1206         {
1207                 notify->OnAction(action, currentState, value);
1208         }
1209 }
1210
1211 //------------------------------------------------------------------------
1212 void CActionMap::AddFlowNodeActionListener(IActionListener* pFlowgraphNodeActionListener)
1213 {
1214         m_flownodesListeners.Add(pFlowgraphNodeActionListener);
1215 }
1216
1217 //------------------------------------------------------------------------
1218 void CActionMap::RemoveFlowNodeActionListener(IActionListener* pFlowgraphNodeActionListener)
1219 {
1220         m_flownodesListeners.Remove(pFlowgraphNodeActionListener);
1221 }
1222
1223 //------------------------------------------------------------------------
1224 void CActionMap::NotifyExtraActionListeners(const ActionId& action, int currentState, float value)
1225 {
1226         for (TActionMapListeners::Notifier notify(m_actionMapListeners); notify.IsValid(); notify.Next())
1227         {
1228                 notify->OnAction(action, currentState, value);
1229         }
1230 }
1231
1232 //------------------------------------------------------------------------
1233 bool CActionMap::LoadFromXML(const XmlNodeRef& actionMapNode)
1234 {
1235         const int iNumDeviceData = m_pActionMapManager->GetNumInputDeviceData();
1236         bool bResult;
1237
1238         int iNumActions = actionMapNode->getChildCount();
1239         for (int i = 0; i < iNumActions; ++i)
1240         {
1241                 XmlNodeRef actionNode = actionMapNode->getChild(i);
1242                 if (strcmp(actionNode->getTag(), "action") != 0)
1243                 {
1244                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::LoadFromXML: Found non action child, actionmaps should only have action children");
1245                         continue;
1246                 }
1247
1248                 const char* szActionName = actionNode->getAttr("name");
1249                 if (!szActionName || strcmp(szActionName, "") == 0)
1250                 {
1251                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::LoadFromXML: Action missing name, ignoring action");
1252                         continue;
1253                 }
1254
1255                 ActionId actionName = ActionId(szActionName);
1256                 CActionMapAction* pAction = (CActionMapAction*)GetAction(actionName);
1257                 if (pAction != NULL)
1258                 {
1259                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::LoadFromXML: Can't add action: %s, already exists", szActionName);
1260                         continue;
1261                 }
1262
1263                 pAction = CreateAndGetAction(actionName);
1264                 if (!pAction)
1265                 {
1266                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::LoadFromXML: Failed to create action: %s", szActionName);
1267                         continue;
1268                 }
1269
1270                 // Actioninput used originally contains default values from constructor, then each LoadActionInputFromXML is cumulative
1271                 // i.e. Only the values in xml will be set to allow attributes specified at topmost level in xml to apply to all children
1272                 SActionInput actionInput;
1273
1274                 if (actionNode->getNumAttributes() > 1) // Contains attributes to apply to all inputs
1275                 {
1276                         bResult = LoadActionInputAttributesFromXML(actionNode, actionInput);
1277                         if (!bResult)
1278                         {
1279                                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::LoadFromXML: Failed loading action input attributes for action: %s", szActionName);
1280                                 continue;
1281                         }
1282
1283                         // Support specifying all devices in 1 line like before
1284
1285                         // All inputs are under a devicetype for organization
1286                         // Devicemapping data should be called from game level using
1287                         // IActionMapManager::AddInputDeviceMapping
1288                         for (int j = 0; j < iNumDeviceData; ++j)
1289                         {
1290                                 const SActionInputDeviceData* pInputDeviceData = m_pActionMapManager->GetInputDeviceDataByIndex(j);
1291
1292                                 const char* szInput = actionNode->getAttr(pInputDeviceData->m_typeStr);
1293                                 if (szInput == NULL || strcmp(szInput, "") == 0) // Not in xml which is fine
1294                                         continue;
1295
1296                                 actionInput.input = szInput;
1297                                 actionInput.defaultInput = szInput;
1298                                 actionInput.inputDevice = pInputDeviceData->m_type;
1299
1300                                 bResult = AddAndBindActionInput(pAction, actionInput);
1301                                 if (!bResult)
1302                                 {
1303                                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::LoadFromXML: Failed binding action input for action: %s, with input: %s", szActionName, szInput);
1304                                         continue;
1305                                 }
1306                         }
1307                 }
1308
1309                 int iNumDeviceChildren = actionNode->getChildCount();
1310
1311                 // Check now for action inputs specified per platform
1312                 if (iNumDeviceChildren > 0)
1313                 {
1314                         // Support specifying separate device with attributes in their own child
1315                         for (int j = 0; j < iNumDeviceChildren; ++j)
1316                         {
1317                                 XmlNodeRef inputDeviceNode = actionNode->getChild(j);
1318
1319                                 EActionInputDevice inputDeviceNodeDeviceType = eAID_Unknown;
1320
1321                                 const SActionInputDeviceData* pInputDeviceData = m_pActionMapManager->GetInputDeviceDataByType(inputDeviceNode->getTag());
1322                                 if (pInputDeviceData != NULL)
1323                                 {
1324                                         inputDeviceNodeDeviceType = pInputDeviceData->m_type;
1325                                 }
1326                                 else
1327                                 {
1328                                         continue;
1329                                 }
1330
1331                                 SActionInput platformInput = actionInput; // Need to copy parent settings since don't want to overwrite for the other nodes
1332
1333                                 bResult = LoadActionInputAttributesFromXML(inputDeviceNode, platformInput);
1334                                 if (!bResult)
1335                                 {
1336                                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::LoadFromXML: Failed loading action input attributes for action: %s", szActionName);
1337                                         continue;
1338                                 }
1339
1340                                 const char* szPlatformInput = inputDeviceNode->getAttr("input");
1341                                 if (szPlatformInput != NULL && strcmp(szPlatformInput, "") != 0) // Device specific key is here, dont need to look for children
1342                                 {
1343                                         platformInput.input = szPlatformInput;
1344                                         platformInput.defaultInput = szPlatformInput;
1345                                         platformInput.inputDevice = inputDeviceNodeDeviceType;
1346
1347                                         bResult = AddAndBindActionInput(pAction, platformInput);
1348                                         if (!bResult)
1349                                         {
1350                                                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::LoadFromXML: Failed binding action input for action: %s, with input: %s", szActionName, szPlatformInput);
1351                                                 continue;
1352                                         }
1353                                 }
1354                                 else
1355                                 {
1356                                         int iNumInputData = inputDeviceNode->getChildCount();
1357                                         for (int k = 0; k < iNumInputData; k++)
1358                                         {
1359                                                 // Go through each of the separate inputs
1360                                                 SActionInput platformChildInput = platformInput;
1361
1362                                                 XmlNodeRef platformChildNode = inputDeviceNode->getChild(k);
1363                                                 if (strcmp(platformChildNode->getTag(), "inputdata") != 0)
1364                                                 {
1365                                                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::LoadFromXML: Children inside platform tags must be inputdata");
1366                                                         continue;
1367                                                 }
1368
1369                                                 const char* szPlatformChildInput = platformChildNode->getAttr("input");
1370                                                 if (szPlatformChildInput == NULL || strcmp(szPlatformChildInput, "") == 0)
1371                                                 {
1372                                                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::LoadFromXML: inputdata tag must contain input");
1373                                                         continue;
1374                                                 }
1375
1376                                                 bResult = LoadActionInputAttributesFromXML(platformChildNode, platformChildInput);
1377                                                 if (!bResult)
1378                                                 {
1379                                                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::LoadFromXML: Failed loading action input attributes on platform child input node for action: %s", szActionName);
1380                                                         continue;
1381                                                 }
1382
1383                                                 platformChildInput.input = szPlatformChildInput;
1384                                                 platformChildInput.defaultInput = szPlatformChildInput;
1385                                                 platformChildInput.inputDevice = pInputDeviceData->m_type;
1386
1387                                                 bResult = AddAndBindActionInput(pAction, platformChildInput);
1388                                                 if (!bResult)
1389                                                 {
1390                                                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::LoadFromXML: Failed binding action input for action: %s, with input: %s", szActionName, szPlatformChildInput);
1391                                                         continue;
1392                                                 }
1393                                         }
1394                                 }
1395                         }
1396                 }
1397         }
1398
1399         return true;
1400 }
1401
1402 bool CActionMap::LoadRebindingDataFromXML(const XmlNodeRef& actionMapNode)
1403 {
1404         int iNumActions = actionMapNode->getChildCount();
1405         for (int i = 0; i < iNumActions; ++i)
1406         {
1407                 XmlNodeRef actionNode = actionMapNode->getChild(i);
1408                 if (strcmp(actionNode->getTag(), "action") != 0)
1409                 {
1410                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::LoadRebindingDataFromXML: Found non action child, actionmaps should only have action children");
1411                         continue;
1412                 }
1413
1414                 const char* szActionName = actionNode->getAttr("name");
1415                 if (szActionName == NULL || strcmp(szActionName, "") == 0)
1416                 {
1417                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::LoadRebindingDataFromXML: Action missing name, ignoring action");
1418                         continue;
1419                 }
1420
1421                 ActionId actionName = ActionId(szActionName);
1422                 CActionMapAction* pAction = (CActionMapAction*)GetAction(actionName);
1423                 if (pAction == NULL)
1424                 {
1425                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::LoadRebindingDataFromXML: Action: %s, doesn't exist, can't rebind", szActionName);
1426                         continue;
1427                 }
1428
1429                 // Check now for action inputs specified per platform
1430                 int iNumRebindInputs = actionNode->getChildCount();
1431                 if (iNumRebindInputs == 0)
1432                         continue; // Shouldn't have empty action tags
1433
1434                 for (int j = 0; j < iNumRebindInputs; ++j)
1435                 {
1436                         XmlNodeRef inputNode = actionNode->getChild(j);
1437                         const char* szInput = inputNode->getAttr("input");
1438                         if (szInput == NULL)
1439                         {
1440                                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::LoadRebindingDataFromXML: Action: %s, has an input tag missing input attribute", szActionName);
1441                                 continue;
1442                         }
1443
1444                         const char* szDevice = inputNode->getAttr("device");
1445                         if (szDevice == NULL || strcmp(szDevice, "") == 0)
1446                         {
1447                                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::LoadRebindingDataFromXML: Action: %s, has an input tag missing device attribute", szActionName);
1448                                 continue;
1449                         }
1450
1451                         const SActionInputDeviceData* pInputDeviceData = m_pActionMapManager->GetInputDeviceDataByType(szDevice);
1452                         if (pInputDeviceData == NULL)
1453                         {
1454                                 continue;
1455                         }
1456
1457                         // Want to allow rebinding without defaultInput to avoid data dependencies
1458                         const char* szDefaultInput = inputNode->getAttr("defaultInput");
1459                         if (szDefaultInput == NULL || strcmp(szDefaultInput, "") == 0) // Assumes rebinding the first input for that device
1460                         {
1461                                 if (stricmp(szInput, "DEFAULT") == 0) // Reset to default
1462                                 {
1463                                         SActionInput* pActionInput = pAction->GetActionInput(pInputDeviceData->m_type, 0);
1464                                         if (pActionInput == NULL)
1465                                         {
1466                                                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::LoadFromXML: Failed trying to find actioninput for input device type: %s", szDevice);
1467                                                 continue;
1468                                         }
1469
1470                                         ReBindActionInput(pAction, pActionInput->defaultInput, pInputDeviceData->m_type, 0);
1471                                 }
1472                                 else
1473                                 {
1474                                         ReBindActionInput(pAction, szInput, pInputDeviceData->m_type, 0);
1475                                 }
1476                         }
1477                         else
1478                         {
1479                                 if (stricmp(szInput, "DEFAULT") == 0) // Reset to default
1480                                 {
1481                                         ReBindActionInput(pAction, szDefaultInput, szDefaultInput);
1482                                 }
1483                                 else
1484                                 {
1485                                         ReBindActionInput(pAction, szDefaultInput, szInput);
1486                                 }
1487                         }
1488                 }
1489         }
1490
1491         return true;
1492 }
1493
1494 bool CActionMap::SaveRebindingDataToXML(XmlNodeRef& actionMapNode) const
1495 {
1496 #if 0
1497         // for debug reasons, we sort the ActionMap alphabetically
1498         // CryName normally sorts by pointer address
1499         std::map<ActionId, SAction, CryNameSorter> sortedActions(m_actions.begin(), m_actions.end());
1500         std::map<ActionId, SAction, CryNameSorter>::const_iterator iter = sortedActions.begin();
1501         std::map<ActionId, SAction, CryNameSorter>::const_iterator iterEnd = sortedActions.end();
1502 #else
1503         TActionMap::const_iterator iter = m_actions.begin();
1504         TActionMap::const_iterator iterEnd = m_actions.end();
1505 #endif
1506
1507         actionMapNode->setAttr("name", m_name);
1508         for (; iter != iterEnd; ++iter)
1509         {
1510                 ActionId actionId = iter->first;
1511                 const CActionMapAction& action = iter->second;
1512                 if (action.GetNumRebindedInputs() == 0)
1513                         continue;
1514
1515                 XmlNodeRef actionNode = actionMapNode->newChild("action");
1516                 actionNode->setAttr("name", actionId.c_str());
1517
1518                 int numActionInputs = action.GetNumActionInputs();
1519                 for (int i = 0; i < numActionInputs; ++i)
1520                 {
1521                         const SActionInput* pActionInput = action.GetActionInput(i);
1522                         CRY_ASSERT(pActionInput != NULL);
1523
1524                         if (pActionInput->input == pActionInput->defaultInput)
1525                         {
1526                                 continue;
1527                         }
1528
1529                         const SActionInputDeviceData* pInputDeviceData = m_pActionMapManager->GetInputDeviceDataByType(pActionInput->inputDevice);
1530                         if (pInputDeviceData == NULL)
1531                         {
1532                                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::SaveRebindingDataToXML: Failed to find device string");
1533                                 continue;
1534                         }
1535
1536                         XmlNodeRef inputDeviceNode = actionNode->newChild("rebind");
1537                         inputDeviceNode->setAttr("device", pInputDeviceData->m_typeStr.c_str());
1538                         inputDeviceNode->setAttr("input", pActionInput->input.c_str());
1539                         inputDeviceNode->setAttr("defaultInput", pActionInput->defaultInput.c_str());
1540                 }
1541         }
1542
1543         return true;
1544 }
1545
1546 bool CActionMap::LoadActionInputAttributesFromXML(const XmlNodeRef& actionInputNode, SActionInput& actionInput)
1547 {
1548         int& activationFlags = actionInput.activationMode;
1549
1550         LoadActivationModeBitAttributeFromXML(actionInputNode, activationFlags, ACTIONINPUT_ONPRESS_STR, eAAM_OnPress);
1551         LoadActivationModeBitAttributeFromXML(actionInputNode, activationFlags, ACTIONINPUT_ONRELEASE_STR, eAAM_OnRelease);
1552         LoadActivationModeBitAttributeFromXML(actionInputNode, activationFlags, ACTIONINPUT_ONHOLD_STR, eAAM_OnHold);
1553         LoadActivationModeBitAttributeFromXML(actionInputNode, activationFlags, ACTIONINPUT_ALWAYS_STR, eAAM_Always);
1554         LoadActivationModeBitAttributeFromXML(actionInputNode, activationFlags, ACTIONINPUT_CONSOLECMD_STR, eAAM_ConsoleCmd);
1555         LoadActivationModeBitAttributeFromXML(actionInputNode, activationFlags, ACTIONINPUT_NOMODIFIERS_STR, eAAM_NoModifiers);
1556         LoadActivationModeBitAttributeFromXML(actionInputNode, activationFlags, ACTIONINPUT_RETRIGGERABLE_STR, eAAM_Retriggerable);
1557
1558         // If not specified, value is taken from constructor (0.0f)
1559         actionInputNode->getAttr(ACTIONINPUT_PRESSTRIGGERDELAY_STR, actionInput.fPressTriggerDelay);
1560         // If not specified, value is taken from constructor (-1.0f) (Disabled)
1561         actionInputNode->getAttr(ACTIONINPUT_PRESSTRIGGERDELAY_REPEATOVERRIDE_STR, actionInput.fPressTriggerDelayRepeatOverride);
1562         // If not specified, value is taken from constructor (0) (Higher number will override when both delayed (i.e. pressing top right on dpad)
1563         actionInputNode->getAttr(ACTIONINPUT_PRESSDELAYPRIORITY_STR, actionInput.iPressDelayPriority);
1564
1565         // If not specified, value is taken from constructor (0.0f)
1566         actionInputNode->getAttr(ACTIONINPUT_HOLDTRIGGERDELAY_STR, actionInput.fHoldTriggerDelay);
1567         // If not specified, value is taken from constructor (0.0f) (Always repeats)
1568         actionInputNode->getAttr(ACTIONINPUT_HOLDREPEATDELAY_STR, actionInput.fHoldRepeatDelay);
1569         // If not specified, value is taken from constructor (-1.0f) (Disabled)
1570         actionInputNode->getAttr(ACTIONINPUT_HOLDTRIGGERDELAY_REPEATOVERRIDE_STR, actionInput.fHoldTriggerDelayRepeatOverride);
1571         // If not specified, value is taken from constructor (-1.0f) (Disabled)
1572         actionInputNode->getAttr(ACTIONINPUT_RELEASETRIGGERTHRESHOLD_STR, actionInput.fReleaseTriggerThreshold);
1573
1574         if (!strcmp(actionInputNode->getAttr(ACTIONINPUT_USEANALOGCOMPARE_STR), "1"))
1575         {
1576                 activationFlags |= eAAM_AnalogCompare;
1577
1578                 const char* analogCompareOp = actionInputNode->getAttr(ACTIONINPUT_ANALOGCOMPAREOP_STR);
1579                 if (analogCompareOp == NULL || strcmp(analogCompareOp, "") == 0)
1580                 {
1581                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::LoadActionInputAttributesFromXML: Failed to find analogCompareOp");
1582                         return false;
1583                 }
1584
1585                 actionInput.analogCompareOp = GetAnalogCompareOpTypeFromStr(analogCompareOp);
1586                 if (actionInput.analogCompareOp == eAACO_None)
1587                 {
1588                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::LoadActionInputAttributesFromXML: Failed to find analogCompareOp");
1589                         return false;
1590                 }
1591
1592                 bool bResult = actionInputNode->getAttr(ACTIONINPUT_ANALOGCOMPAREVAL_STR, actionInput.fAnalogCompareVal);
1593                 if (!bResult)
1594                 {
1595                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::LoadActionInputAttributesFromXML: Failed to find analogCompareVal");
1596                         return false;
1597                 }
1598         }
1599
1600         // Input blocking
1601         const char* inputsToBlock = actionInputNode->getAttr(ACTIONINPUT_INPUTSTOBLOCK_STR);
1602         if (inputsToBlock != NULL && strcmp(inputsToBlock, "") != 0)
1603         {
1604                 SActionInputBlockData& inputBlockData = actionInput.inputBlockData;
1605
1606                 if (strcmp(inputsToBlock, ACTIONINPUT_INPUTSTOBLOCK_SPECIALTYPE_CLEARALL_STR) == 0)
1607                 {
1608                         inputBlockData.blockType = eAIBT_Clear;
1609                 }
1610                 else // Must contain list of inputs separated by |
1611                 {
1612                         // Must contain a valid block time
1613                         actionInputNode->getAttr(ACTIONINPUT_INPUTBLOCKTIME_STR, inputBlockData.fBlockDuration);
1614                         if (inputBlockData.fBlockDuration < FLT_EPSILON)
1615                         {
1616                                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::LoadActionInputAttributesFromXML: Must have a valid blockTime, value is: %.2f", inputBlockData.fBlockDuration);
1617                                 return false;
1618                         }
1619
1620                         // Read in the blocking activation (Default is always, matches all specified action activations)
1621                         const char* inputBlockActivation = actionInputNode->getAttr(ACTIONINPUT_INPUTBLOCKACTIVATION_STR);
1622                         bool useAlwaysActivation;
1623                         if (inputBlockActivation != NULL && strcmp(inputBlockActivation, "") != 0)
1624                         {
1625                                 useAlwaysActivation = false;
1626                                 string inputsBlockActivationStr(inputBlockActivation);
1627                                 int curPos = 0;
1628                                 string singleBlockActivation = inputsBlockActivationStr.Tokenize("|", curPos);
1629                                 bool bEmpty = singleBlockActivation.empty();
1630                                 if (bEmpty) // Only 1 input
1631                                 {
1632                                         singleBlockActivation = inputsBlockActivationStr;
1633                                         curPos = 0;
1634                                 }
1635
1636                                 do
1637                                 {
1638                                         if (strcmp(singleBlockActivation, ACTIONINPUT_ONPRESS_STR) == 0)
1639                                         {
1640                                                 inputBlockData.activationMode |= eIS_Pressed;
1641                                         }
1642                                         else if (strcmp(singleBlockActivation, ACTIONINPUT_ONHOLD_STR) == 0)
1643                                         {
1644                                                 inputBlockData.activationMode |= eIS_Down;
1645                                         }
1646                                         else if (strcmp(singleBlockActivation, ACTIONINPUT_ONRELEASE_STR) == 0)
1647                                         {
1648                                                 inputBlockData.activationMode |= eIS_Released;
1649                                         }
1650                                         else if (strcmp(inputBlockActivation, ACTIONINPUT_ALWAYS_STR) == 0)
1651                                         {
1652                                                 useAlwaysActivation = true;
1653                                                 break;
1654                                         }
1655                                         else
1656                                         {
1657                                                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::LoadActionInputAttributesFromXML: Invalid block activation: %s", singleBlockActivation.c_str());
1658                                                 return false;
1659                                         }
1660
1661                                         if (bEmpty)
1662                                         {
1663                                                 break;
1664                                         }
1665
1666                                         singleBlockActivation = inputsBlockActivationStr.Tokenize("|", curPos);
1667                                         bEmpty = singleBlockActivation.empty();
1668                                 }
1669                                 while (!bEmpty);
1670                         }
1671                         else
1672                         {
1673                                 useAlwaysActivation = true;
1674                         }
1675
1676                         if (useAlwaysActivation)
1677                         {
1678                                 inputBlockData.activationMode |= eIS_Pressed;
1679                                 inputBlockData.activationMode |= eIS_Down;
1680                                 inputBlockData.activationMode |= eIS_Released;
1681                         }
1682
1683                         // Now read in all the inputs to block, separated by |
1684                         string inputsToBlockStr(inputsToBlock);
1685                         std::vector<string> inputsToBlockVec;
1686                         int curPos = 0;
1687                         string singleInput = inputsToBlockStr.Tokenize("|", curPos);
1688                         if (singleInput.empty()) // Only 1 input
1689                         {
1690                                 inputsToBlockVec.push_back(inputsToBlockStr);
1691                         }
1692                         else
1693                         {
1694                                 do
1695                                 {
1696                                         inputsToBlockVec.push_back(singleInput);
1697                                         singleInput = inputsToBlockStr.Tokenize("|", curPos);
1698                                 }
1699                                 while (!singleInput.empty());
1700                         }
1701
1702                         // Read in the device index (Default is all device indices)
1703                         int iDeviceIndex = -1;
1704                         actionInputNode->getAttr(ACTIONINPUT_INPUTBLOCKDEVICEINDEX_STR, iDeviceIndex);
1705
1706                         if (iDeviceIndex != -1)
1707                         {
1708                                 inputBlockData.bAllDeviceIndices = false;
1709                                 inputBlockData.deviceIndex = (uint8)iDeviceIndex;
1710                         }
1711
1712                         for (size_t i = 0; i < inputsToBlockVec.size(); i++)
1713                         {
1714                                 const SInputSymbol* pInputSymbol = gEnv->pInput ? gEnv->pInput->GetSymbolByName(inputsToBlockVec[i]) : NULL;
1715                                 if (!pInputSymbol)
1716                                 {
1717                                         // Data is currently read all in on pc, dont show warnings until thats changed
1718                                         // CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::LoadActionInputAttributesFromXML: Failed to find input symbol for input name: %s", inputsToBlockVec[i].c_str());
1719                                         continue;
1720                                 }
1721
1722                                 SActionInputBlocker inputBlockerToSend(pInputSymbol->keyId);
1723                                 inputBlockData.inputs.push_back(inputBlockerToSend);
1724                         }
1725                         if (!inputBlockData.inputs.empty())
1726                         {
1727                                 inputBlockData.blockType = eAIBT_BlockInputs; // Only having this makes enables blocking
1728                         }
1729
1730                         /* Data is currently read all in on pc, dont show warnings until thats changed
1731                            else
1732                            {
1733                            CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::LoadActionInputAttributesFromXML: Failed to find any inputs to block for inputs: %s", inputsToBlock);
1734                            return false;
1735                            }
1736                          */
1737                 }
1738         }
1739
1740         return true;
1741 }
1742
1743 bool CActionMap::SaveActionInputAttributesToXML(XmlNodeRef& actionInputNode, const SActionInput& actionInput) const
1744 {
1745         const int activationFlags = actionInput.activationMode;
1746
1747         SaveActivationModeBitAttributeToXML(actionInputNode, activationFlags, ACTIONINPUT_ONPRESS_STR, eAAM_OnPress);
1748         SaveActivationModeBitAttributeToXML(actionInputNode, activationFlags, ACTIONINPUT_ONRELEASE_STR, eAAM_OnRelease);
1749         SaveActivationModeBitAttributeToXML(actionInputNode, activationFlags, ACTIONINPUT_ALWAYS_STR, eAAM_Always);
1750         SaveActivationModeBitAttributeToXML(actionInputNode, activationFlags, ACTIONINPUT_CONSOLECMD_STR, eAAM_ConsoleCmd);
1751         SaveActivationModeBitAttributeToXML(actionInputNode, activationFlags, ACTIONINPUT_NOMODIFIERS_STR, eAAM_NoModifiers);
1752         SaveActivationModeBitAttributeToXML(actionInputNode, activationFlags, ACTIONINPUT_RETRIGGERABLE_STR, eAAM_Retriggerable);
1753
1754         if (actionInput.activationMode & eAAM_OnHold)
1755         {
1756                 actionInputNode->setAttr(ACTIONINPUT_ONHOLD_STR, "1");
1757                 actionInputNode->setAttr(ACTIONINPUT_HOLDTRIGGERDELAY_STR, actionInput.fHoldTriggerDelay);
1758                 actionInputNode->setAttr(ACTIONINPUT_HOLDREPEATDELAY_STR, actionInput.fHoldRepeatDelay);
1759                 actionInputNode->setAttr(ACTIONINPUT_HOLDTRIGGERDELAY_REPEATOVERRIDE_STR, actionInput.fHoldTriggerDelayRepeatOverride);
1760         }
1761         else
1762         {
1763                 actionInputNode->setAttr(ACTIONINPUT_ONHOLD_STR, "0");
1764         }
1765
1766         if (actionInput.activationMode & eAAM_AnalogCompare)
1767         {
1768                 actionInputNode->setAttr(ACTIONINPUT_USEANALOGCOMPARE_STR, "1");
1769                 actionInputNode->setAttr(ACTIONINPUT_ANALOGCOMPAREOP_STR, GetAnalogCompareOpStr(actionInput.analogCompareOp));
1770                 actionInputNode->setAttr(ACTIONINPUT_ANALOGCOMPAREVAL_STR, actionInput.fAnalogCompareVal);
1771         }
1772         else
1773         {
1774                 actionInputNode->setAttr(ACTIONINPUT_USEANALOGCOMPARE_STR, "0");
1775         }
1776
1777         // Input blocking
1778         const SActionInputBlockData& inputBlockData = actionInput.inputBlockData;
1779         if (inputBlockData.blockType != eAIBT_None)
1780         {
1781                 if (inputBlockData.blockType == eAIBT_Clear)
1782                 {
1783                         actionInputNode->setAttr(ACTIONINPUT_INPUTSTOBLOCK_STR, ACTIONINPUT_INPUTSTOBLOCK_SPECIALTYPE_CLEARALL_STR);
1784                 }
1785                 else // Normal blocking inputs
1786                 {
1787                         if (inputBlockData.inputs.empty())
1788                         {
1789                                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::SaveActionInputAttributesToXML: Failed, using normal blocking inputs type but dont have any inputs");
1790                                 return false;
1791                         }
1792
1793                         if (inputBlockData.fBlockDuration <= (0.0f - FLT_EPSILON))
1794                         {
1795                                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::SaveActionInputAttributesToXML: Failed, using normal blocking inputs type but don't have valid block duration");
1796                                 return false;
1797                         }
1798                         actionInputNode->setAttr(ACTIONINPUT_INPUTBLOCKTIME_STR, inputBlockData.fBlockDuration);
1799
1800                         // Save input blocking activation mode
1801                         if ((inputBlockData.activationMode & eIS_Pressed) &&
1802                             (inputBlockData.activationMode & eIS_Down) &&
1803                             (inputBlockData.activationMode & eIS_Released))
1804                         {
1805                                 actionInputNode->setAttr(ACTIONINPUT_INPUTBLOCKACTIVATION_STR, ACTIONINPUT_ALWAYS_STR);
1806                         }
1807                         else
1808                         {
1809                                 CryFixedStringT<32> inputBlockActivationStr("");
1810                                 bool bAddedActivationMode = false;
1811                                 if (inputBlockData.activationMode & eIS_Pressed)
1812                                 {
1813                                         inputBlockActivationStr = ACTIONINPUT_ONPRESS_STR;
1814                                         bAddedActivationMode = true;
1815                                 }
1816                                 if (inputBlockData.activationMode & eIS_Down)
1817                                 {
1818                                         if (bAddedActivationMode)
1819                                         {
1820                                                 inputBlockActivationStr += "|";
1821                                         }
1822                                         inputBlockActivationStr += ACTIONINPUT_ONHOLD_STR;
1823                                         bAddedActivationMode = true;
1824                                 }
1825                                 if (inputBlockData.activationMode & eIS_Released)
1826                                 {
1827                                         if (bAddedActivationMode)
1828                                         {
1829                                                 inputBlockActivationStr += "|";
1830                                         }
1831                                         inputBlockActivationStr += ACTIONINPUT_ONRELEASE_STR;
1832                                 }
1833
1834                                 actionInputNode->setAttr(ACTIONINPUT_INPUTBLOCKACTIVATION_STR, inputBlockActivationStr.c_str());
1835                         }
1836
1837                         // Now save the blocked inputs
1838                         string blockedInputsStr("");
1839                         for (size_t i = 0; i < inputBlockData.inputs.size(); i++)
1840                         {
1841                                 const SActionInputBlocker& inputBlocker = inputBlockData.inputs[i];
1842
1843                                 if (i != 0)
1844                                 {
1845                                         blockedInputsStr += "|";
1846                                 }
1847
1848                                 const char* szKeyName = gEnv->pInput->GetKeyName(inputBlocker.keyId);
1849                                 if (!szKeyName)
1850                                 {
1851                                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMap::LoadActionInputAttributesFromXML: Failed to translate keyname for key id: %d", (int)inputBlocker.keyId);
1852                                         return false;
1853                                 }
1854
1855                                 blockedInputsStr += szKeyName;
1856                         }
1857
1858                         // Now save device index data
1859                         if (!inputBlockData.bAllDeviceIndices) // Default is true so dont need to save to xml
1860                         {
1861                                 actionInputNode->setAttr(ACTIONINPUT_INPUTBLOCKDEVICEINDEX_STR, inputBlockData.deviceIndex);
1862                         }
1863                 }
1864         }
1865
1866         return true;
1867 }
1868
1869 //------------------------------------------------------------------------
1870 void CActionMap::LoadActivationModeBitAttributeFromXML(const XmlNodeRef& attributeNode, int& activationFlags, const char* szActivationModeName, EActionActivationMode activationMode)
1871 {
1872         int readFlag;
1873
1874         if (attributeNode->getAttr(szActivationModeName, readFlag))
1875         {
1876                 if (readFlag == 1)
1877                 {
1878                         activationFlags |= activationMode;
1879                 }
1880                 else
1881                 {
1882                         activationFlags &= ~activationMode;
1883                 }
1884         }
1885 }
1886
1887 //------------------------------------------------------------------------
1888 void CActionMap::SaveActivationModeBitAttributeToXML(XmlNodeRef& attributeNode, const int activationFlags, const char* szActivationModeName, EActionActivationMode activationMode) const
1889 {
1890         if (activationFlags & activationMode)
1891         {
1892                 attributeNode->setAttr(szActivationModeName, "1");
1893         }
1894         else
1895         {
1896                 attributeNode->setAttr(szActivationModeName, "0");
1897         }
1898 }
1899
1900 #define USE_SORTED_ACTIONS_ITERATOR
1901 #undef  USE_SORTED_ACTIONS_ITERATOR
1902
1903 //------------------------------------------------------------------------
1904 IActionMapActionIteratorPtr CActionMap::CreateActionIterator()
1905 {
1906         class CActionInfo : public IActionMapActionIterator
1907         {
1908 #ifndef USE_SORTED_ACTIONS_ITERATOR
1909                 typedef TActionMap::iterator                                TIterator;
1910 #else
1911                 typedef std::map<ActionId, CActionMapAction, CryNameSorter> TSortedActionMap;
1912                 typedef TSortedActionMap::iterator                          TIterator;
1913 #endif
1914
1915         public:
1916                 CActionInfo(TActionMap::iterator& itBegin, TActionMap::iterator& itEnd)
1917                         : m_nRefs(0)
1918                 {
1919 #ifdef USE_SORTED_ACTIONS_ITERATOR
1920                         m_sortedActions.insert(itBegin, itEnd);
1921                         m_cur = m_sortedActions.begin();
1922                         m_end = m_sortedActions.end();
1923 #else
1924                         m_cur = itBegin;
1925                         m_end = itEnd;
1926 #endif
1927                 }
1928
1929                 virtual ~CActionInfo()
1930                 {
1931                 }
1932
1933                 const IActionMapAction* Next()
1934                 {
1935                         if (m_cur == m_end)
1936                                 return NULL;
1937                         const CActionMapAction& action = m_cur->second;
1938
1939                         ++m_cur;
1940                         return &action;
1941                 }
1942
1943                 void AddRef()
1944                 {
1945                         ++m_nRefs;
1946                 }
1947
1948                 void Release()
1949                 {
1950                         if (--m_nRefs <= 0)
1951                                 delete this;
1952                 }
1953                 int              m_nRefs;
1954                 TIterator        m_cur;
1955                 TIterator        m_end;
1956 #ifdef USE_SORTED_ACTIONS_ITERATOR
1957                 TSortedActionMap m_sortedActions;
1958 #endif
1959         };
1960         TActionMap::iterator actionsBegin(m_actions.begin());
1961         TActionMap::iterator actionsEnd(m_actions.end());
1962         return new CActionInfo(actionsBegin, actionsEnd);
1963 }
1964
1965 void CActionMap::Enable(bool enable)
1966 {
1967         // detect nop
1968         if (enable == m_enabled)
1969                 return;
1970
1971         // now things get a bit interesting, when we get disabled we "release" all our
1972         // active actions
1973         if (!enable)
1974         {
1975                 TActionMap::iterator it = m_actions.begin();
1976                 TActionMap::iterator end = m_actions.end();
1977                 for (; it != end; ++it)
1978                 {
1979                         ReleaseActionIfActiveInternal(it->second);
1980                 }
1981         }
1982
1983         // finally set the flag
1984         m_enabled = enable;
1985
1986         if (m_pActionMapManager)
1987         {
1988                 m_pActionMapManager->BroadcastActionMapEvent(SActionMapEvent(SActionMapEvent::eActionMapManagerEvent_ActionMapStatusChanged, (UINT_PTR)this, (UINT_PTR)m_enabled));
1989         }
1990 }
1991
1992 void CActionMap::ReleaseActionIfActive(const ActionId& actionId)
1993 {
1994         TActionMap::iterator it = m_actions.find(actionId);
1995         if (it != m_actions.end())
1996         {
1997                 ReleaseActionIfActiveInternal(it->second);
1998         }
1999 }
2000
2001 void CActionMap::ReleaseActionIfActiveInternal(CActionMapAction& action)
2002 {
2003         bool bFireOnActionRelease = false;
2004         bool bFireOnActionAlways = false;
2005
2006         int numActionInputs = action.GetNumActionInputs();
2007         for (int i = 0; i < numActionInputs; ++i)
2008         {
2009                 SActionInput* pActionInput = action.GetActionInput(i);
2010                 CRY_ASSERT(pActionInput != NULL);
2011
2012                 bool hasReleaseMode = (pActionInput->activationMode & eAAM_OnRelease) != 0;
2013                 bool isPressedOrDown = (pActionInput->currentState == eIS_Pressed) || (pActionInput->currentState == eIS_Down);
2014                 bool isChanged = pActionInput->currentState == eIS_Changed;
2015
2016                 if (hasReleaseMode && isPressedOrDown)
2017                 {
2018                         bFireOnActionRelease = true;
2019                 }
2020
2021                 if (isChanged)
2022                 {
2023                         bFireOnActionAlways = true;
2024                 }
2025
2026                 pActionInput->fCurrentHoldValue = 0.f;
2027         }
2028
2029         if (bFireOnActionRelease)
2030         {
2031                 IActionListener* pEntityListener = nullptr;
2032
2033                 if (IEntity* pEntity = gEnv->pEntitySystem->GetEntity(m_listenerId))
2034                 {
2035                         if (IGameObject* pGameObject = static_cast<IGameObject*>(pEntity->GetProxy(ENTITY_PROXY_USER)))
2036                         {
2037                                 pEntityListener = pGameObject;
2038                         }
2039                 }
2040
2041                 if (pEntityListener)
2042                 {
2043                         pEntityListener->OnAction(action.GetActionId(), eAAM_OnRelease, 0.0f);
2044                 }
2045
2046                 NotifyExtraActionListeners(action.GetActionId(), eAAM_OnRelease, 0.0f);
2047         }
2048
2049         if (bFireOnActionAlways)
2050         {
2051                 IActionListener* pEntityListener = nullptr;
2052
2053                 if (IEntity* pEntity = gEnv->pEntitySystem->GetEntity(m_listenerId))
2054                 {
2055                         if (IGameObject* pGameObject = static_cast<IGameObject*>(pEntity->GetProxy(ENTITY_PROXY_USER)))
2056                                 pEntityListener = pGameObject;
2057                 }
2058
2059                 if (pEntityListener)
2060                 {
2061                         pEntityListener->OnAction(action.GetActionId(), eAAM_Always, 0.0f);
2062                 }
2063
2064                 NotifyExtraActionListeners(action.GetActionId(), eAAM_Always, 0.0f);
2065         }
2066 }
2067
2068 EActionAnalogCompareOperation CActionMap::GetAnalogCompareOpTypeFromStr(const char* szTypeStr)
2069 {
2070         EActionAnalogCompareOperation compareOpType = eAACO_None;
2071         if (!strcmp(szTypeStr, s_analogCompareOpEqualsStr))
2072         {
2073                 compareOpType = eAACO_Equals;
2074         }
2075         else if (!strcmp(szTypeStr, s_analogCompareOpNotEqualsStr))
2076         {
2077                 compareOpType = eAACO_NotEquals;
2078         }
2079         else if (!strcmp(szTypeStr, s_analogCompareOpGreaterThanStr))
2080         {
2081                 compareOpType = eAACO_GreaterThan;
2082         }
2083         else if (!strcmp(szTypeStr, s_analogCompareOpLessThanStr))
2084         {
2085                 compareOpType = eAACO_LessThan;
2086         }
2087
2088         return compareOpType;
2089 }
2090
2091 const char* CActionMap::GetAnalogCompareOpStr(EActionAnalogCompareOperation compareOpType) const
2092 {
2093         if (compareOpType == eAACO_Equals)
2094         {
2095                 return s_analogCompareOpEqualsStr;
2096         }
2097         else if (compareOpType == eAACO_NotEquals)
2098         {
2099                 return s_analogCompareOpNotEqualsStr;
2100         }
2101         else if (compareOpType == eAACO_GreaterThan)
2102         {
2103                 return s_analogCompareOpGreaterThanStr;
2104         }
2105         else if (compareOpType == eAACO_LessThan)
2106         {
2107                 return s_analogCompareOpLessThanStr;
2108         }
2109         else
2110         {
2111                 return NULL;
2112         }
2113 }
2114
2115 void CActionMap::EnumerateActions(IActionMapPopulateCallBack* pCallBack) const
2116 {
2117         for (TActionMap::const_iterator actionCit = m_actions.begin(); actionCit != m_actions.end(); ++actionCit)
2118         {
2119                 pCallBack->AddActionName(actionCit->first.c_str());
2120         }
2121 }
2122
2123 void CActionMap::GetMemoryUsage(ICrySizer* s) const
2124 {
2125         s->AddObject(m_actions);
2126         s->AddObject(m_name);
2127 }