BVB Source Codes

CRYENGINE Show ActionMapManager.cpp Source code

Return Download CRYENGINE: download ActionMapManager.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. /*************************************************************************
  4.    -------------------------------------------------------------------------
  5.    $Id$
  6.    $DateTime$
  7.  
  8.    -------------------------------------------------------------------------
  9.    History:
  10.    - 7:9:2004   17:42 : Created by M谩rcio Martins
  11.    - 15:9:2010  12:30 : Revised by Dean Claassen
  12.  
  13. *************************************************************************/
  14. #include "StdAfx.h"
  15. #include "ActionMapManager.h"
  16. #include "ActionMap.h"
  17. #include "ActionFilter.h"
  18. #include <CryCore/CryCrc32.h>
  19. #include "GameObjects/GameObject.h"
  20. #include <CryCore/Platform/IPlatformOS.h>
  21.  
  22. CActionMapManager* CActionMapManager::s_pThis = nullptr;
  23.  
  24. //------------------------------------------------------------------------
  25. CActionMapManager::CActionMapManager(IInput* pInput)
  26.         : m_loadedXMLPath(""),
  27.         m_pInput(pInput),
  28.         m_enabled(true),
  29.         m_bRefiringInputs(false),
  30.         m_bDelayedRemoveAllRefiringData(false),
  31.         m_bIncomingInputRepeated(false),
  32.         m_bRepeatedInputHoldTriggerFired(false),
  33.         m_currentInputKeyID(eKI_Unknown),
  34.         m_defaultEntityId(INVALID_ENTITYID),
  35.         m_version(-1)    // the first actionmap/filter sets the version
  36. {
  37.         CRY_ASSERT(!s_pThis);
  38.         s_pThis = this;
  39.  
  40.         if (m_pInput)
  41.         {
  42.                 m_pInput->AddEventListener(this);
  43.         }
  44.  
  45. #ifndef _RELEASE
  46.         i_listActionMaps = 0;
  47.         REGISTER_CVAR(i_listActionMaps, i_listActionMaps, 0, "List action maps/filters on screen (1 = list all, 2 = list blocked inputs only)");
  48.         REGISTER_COMMAND("i_reloadActionMaps", ReloadActionMaps, VF_CHEAT, "Reloads action maps");
  49. #endif
  50. }
  51.  
  52. //------------------------------------------------------------------------
  53. CActionMapManager::~CActionMapManager()
  54. {
  55.         if (m_pInput)
  56.         {
  57.                 m_pInput->RemoveEventListener(this);
  58.         }
  59.  
  60.         Clear();
  61.         RemoveAllAlwaysActionListeners();
  62. }
  63.  
  64. //------------------------------------------------------------------------
  65. bool CActionMapManager::OnInputEvent(const SInputEvent& event)
  66. {
  67.         FUNCTION_PROFILER(GetISystem(), PROFILE_ACTION);
  68.  
  69.         if (!m_enabled)
  70.                 return false;
  71.  
  72.         // no actions while console is open
  73.         if (gEnv->pConsole->IsOpened())
  74.                 return false;
  75.  
  76.         if (gEnv->IsEditor() && gEnv->pGameFramework->IsEditing())
  77.                 return false;
  78.  
  79.         if (event.keyName.c_str() && event.keyName.c_str()[0] == 0)
  80.                 return false;
  81.  
  82.         // Filter alt+enter which toggles between fullscreen and windowed mode and shouldn't be processed here
  83.         if ((event.modifiers & eMM_Alt) && event.keyId == eKI_Enter)
  84.                 return false;
  85.  
  86.         // Check if input is repeated and record (Used for bUseHoldTriggerDelayRepeatOverride)
  87.         if (event.keyId < eKI_SYS_Commit) // Ignore special types and unknown
  88.         {
  89.                 if (m_currentInputKeyID != event.keyId)
  90.                 {
  91.                         m_currentInputKeyID = event.keyId;
  92.                         m_bIncomingInputRepeated = false;
  93.                         SetRepeatedInputHoldTriggerFired(false);
  94.                 }
  95.                 else
  96.                 {
  97.                         m_bIncomingInputRepeated = true;
  98.                 }
  99.         }
  100.  
  101.         // Process priority list based on event
  102.         TBindPriorityList priorityList;
  103.         bool bHasItems = CreateEventPriorityList(event, priorityList);
  104.         if (bHasItems)
  105.         {
  106.                 return HandleAcceptedEvents(event, priorityList);
  107.         }
  108.  
  109.         return false; // Not handled
  110. }
  111.  
  112. //------------------------------------------------------------------------
  113. void CActionMapManager::Update()
  114. {
  115.         if (!m_enabled)
  116.         {
  117.                 return;
  118.         }
  119.  
  120.         // Process refired events
  121.         UpdateRefiringInputs();
  122.  
  123.         for (TActionMapMap::iterator it = m_actionMaps.begin(); it != m_actionMaps.end(); ++it)
  124.         {
  125.                 CActionMap* pAm = it->second;
  126.                 if (pAm->Enabled())
  127.                 {
  128.                         pAm->InputProcessed();
  129.                 }
  130.         }
  131.  
  132. #ifndef _RELEASE
  133.         if (i_listActionMaps)
  134.         {
  135.                 const float color[4] = { 1, 1, 1, 1 };
  136.                 const float textSize = 1.5f;
  137.                 const bool renderAll = (i_listActionMaps != 2);
  138.                 const float xMargin = 40.f;
  139.  
  140.                 IFFont* defaultFont = gEnv->pCryFont->GetFont("default");
  141.                 float yPos = gEnv->pRenderer->GetHeight() - 100.f;
  142.                 float secondColumnOffset = 0.f;
  143.  
  144.                 STextDrawContext ctx;
  145.                 ctx.SetSizeIn800x600(false);
  146.                 ctx.SetSize(Vec2(UIDRAW_TEXTSIZEFACTOR * textSize, UIDRAW_TEXTSIZEFACTOR * textSize));
  147.  
  148.                 if (defaultFont)
  149.                 {
  150.                         TActionFilterMap::iterator it = m_actionFilters.begin();
  151.                         TActionFilterMap::iterator itEnd = m_actionFilters.end();
  152.                         while (it != itEnd)
  153.                         {
  154.                                 const bool isEnabled = it->second->Enabled();
  155.  
  156.                                 if (renderAll || isEnabled)
  157.                                 {
  158.                                         string message;
  159.                                         message.Format("%sFilter '%s' %s", isEnabled ? "$7" : "$5", it->second->GetName(), isEnabled ? "blocking inputs" : "allowing inputs");
  160.  
  161.                                         const float width = defaultFont->GetTextSize(message, true, ctx).x + 5.f;
  162.                                         secondColumnOffset = max(width, secondColumnOffset);
  163.  
  164.                                         IRenderAuxText::Draw2dLabel(xMargin, yPos, 1.5f, color, false, "%s", message.c_str());
  165.                                         yPos -= 15.f;
  166.                                 }
  167.  
  168.                                 ++it;
  169.                         }
  170.                 }
  171.  
  172.                 yPos = gEnv->pRenderer->GetHeight() - 100.f;
  173.  
  174.                 for (TActionMapMap::iterator it = m_actionMaps.begin(); it != m_actionMaps.end(); ++it)
  175.                 {
  176.                         CActionMap* pAm = it->second;
  177.                         const bool isEnabled = pAm->Enabled();
  178.                         if (renderAll || !isEnabled)
  179.                         {
  180.                                 IRenderAuxText::Draw2dLabel(xMargin + secondColumnOffset, yPos, 1.5f, color, false, "%sAction map '%s' %s", isEnabled ? "$3" : "$4", pAm->GetName(), isEnabled ? "enabled" : "disabled");
  181.                                 yPos -= 15.f;
  182.                         }
  183.                 }
  184.         }
  185. #endif
  186. }
  187.  
  188. //------------------------------------------------------------------------
  189. void CActionMapManager::Reset()
  190. {
  191.         for (TActionMapMap::iterator it = m_actionMaps.begin(); it != m_actionMaps.end(); ++it)
  192.         {
  193.                 it->second->Reset();
  194.         }
  195. }
  196.  
  197. //------------------------------------------------------------------------
  198. void CActionMapManager::Clear()
  199. {
  200.         RemoveAllActionMaps();
  201.         RemoveAllFilters();
  202.  
  203.         m_preloadedControllerLayouts.clear();
  204. }
  205.  
  206. //------------------------------------------------------------------------
  207. bool CActionMapManager::InitActionMaps(const char* filename)
  208. {
  209.         XmlNodeRef rootNode = GetISystem()->LoadXmlFromFile(filename);
  210.         if (rootNode)
  211.         {
  212.                 Clear();
  213.                 ClearInputDevicesMappings();
  214.                 ClearStoredCurrentInputData();
  215.  
  216.                 XmlNodeRef platformsNode = rootNode->findChild("platforms");
  217.                 if (platformsNode)
  218.                 {
  219.                         XmlNodeRef platform = platformsNode->findChild(GetISystem()->GetPlatformOS()->GetPlatformName());
  220.                         if (platform)
  221.                         {
  222.                                 BYTE devices(eAID_KeyboardMouse | eAID_XboxPad | eAID_PS4Pad | eAID_OculusTouch);
  223.  
  224.                                 if (!strcmp(platform->getAttr("keyboard"), "0"))      devices &= ~eAID_KeyboardMouse;
  225.                                 if (!strcmp(platform->getAttr("xboxpad"), "0"))       devices &= ~eAID_XboxPad;
  226.                                 if (!strcmp(platform->getAttr("ps4pad"), "0"))        devices &= ~eAID_PS4Pad;
  227.                                 if (!strcmp(platform->getAttr("oculustouch"), "0"))   devices &= ~eAID_OculusTouch;
  228.  
  229.                                 if (devices & eAID_KeyboardMouse) AddInputDeviceMapping(eAID_KeyboardMouse, "keyboard");
  230.                                 if (devices & eAID_XboxPad)       AddInputDeviceMapping(eAID_XboxPad, "xboxpad");
  231.                                 if (devices & eAID_PS4Pad)        AddInputDeviceMapping(eAID_PS4Pad, "ps4pad");
  232.                                 if (devices & eAID_OculusTouch)   AddInputDeviceMapping(eAID_OculusTouch, "oculustouch");
  233.  
  234.                                 SetLoadFromXMLPath(filename);
  235.                                 if (LoadFromXML(rootNode))
  236.                                 {
  237.                                         BroadcastActionMapEvent(SActionMapEvent(SActionMapEvent::eActionMapManagerEvent_ActionMapsInitialized, (UINT_PTR)0, (UINT_PTR)0));
  238.                                         return true;
  239.                                 }
  240.                         }
  241.                         else
  242.                         {
  243.                                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMapManager::InitActionMaps: Failed to find platform defintions for '%s', action mappings loading will fail", GetISystem()->GetPlatformOS()->GetPlatformName());
  244.                         }
  245.                 }
  246.                 else
  247.                 {
  248.                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMapManager::InitActionMaps: Failed to find XML node 'platforms', action mappings loading will fail");
  249.                 }
  250.         }
  251.         else
  252.         {
  253.                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMapManager::InitActionMaps: Failed to open %s, action mappings loading will fail", filename);
  254.         }
  255.         return false;
  256. };
  257.  
  258. //------------------------------------------------------------------------
  259. bool CActionMapManager::LoadFromXML(const XmlNodeRef& node)
  260. {
  261.         int version = -1;
  262.         if (!node->getAttr("version", version))
  263.         {
  264.                 GameWarning("Obsolete action map format - version info is missing");
  265.                 return false;
  266.         }
  267.         m_version = version;
  268.  
  269.         //      load action maps
  270.         int nChildren = node->getChildCount();
  271.         for (int i = 0; i < nChildren; ++i)
  272.         {
  273.                 XmlNodeRef child = node->getChild(i);
  274.                 if (!strcmp(child->getTag(), "actionmap"))
  275.                 {
  276.                         const char* actionMapName = child->getAttr("name");
  277.                         IActionMap* pActionMap = CreateActionMap(actionMapName);
  278.                         if (!pActionMap)
  279.                         {
  280.                                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMapManager::LoadFromXML: Unable to create actionmap: %s", actionMapName);
  281.                                 continue;
  282.                         }
  283.  
  284.                         bool bResult = pActionMap->LoadFromXML(child);
  285.                         if (!bResult)
  286.                         {
  287.                                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMapManager::LoadFromXML: Failed to serialize actionmap: %s", actionMapName);
  288.                                 continue;
  289.                         }
  290.                 }
  291.  
  292.                 if (!strcmp(child->getTag(), "actionfilter"))
  293.                 {
  294.                         const char* actionFilterName = child->getAttr("name");
  295.                         const char* actionFilterType = child->getAttr("type");
  296.                         IActionFilter* pActionFilter = CreateActionFilter(actionFilterName, !stricmp(actionFilterType, "actionPass") ? eAFT_ActionPass : eAFT_ActionFail);
  297.                         if (!pActionFilter)
  298.                         {
  299.                                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMapManager::LoadFromXML: Unable to create actionfilter: %s", actionFilterName);
  300.                                 continue;
  301.                         }
  302.  
  303.                         bool bResult = pActionFilter->SerializeXML(child, true);
  304.                         if (!bResult)
  305.                         {
  306.                                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMapManager::SerializeXML: Failed to serialize actionfilter: %s", actionFilterName);
  307.                                 continue;
  308.                         }
  309.                 }
  310.  
  311.                 if (!strcmp(child->getTag(), "controllerlayouts"))
  312.                 {
  313.                         int nLayoutChildren = child->getChildCount();
  314.                         for (int j = 0; j < nLayoutChildren; ++j)
  315.                         {
  316.                                 XmlNodeRef layoutChild = child->getChild(j);
  317.                                 if (!PreloadControllerLayout(layoutChild))
  318.                                 {
  319.                                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMapManager::SerializeXML: Failed to serialize controllerlayout in line %i", j);
  320.                                 }
  321.                         }
  322.                 }
  323.         }
  324.  
  325.         return true;
  326. }
  327.  
  328. //------------------------------------------------------------------------
  329. bool CActionMapManager::PreloadControllerLayout(const XmlNodeRef& controllerLayout)
  330. {
  331.         const char* szLayoutName = controllerLayout->getAttr("name");
  332.         const char* szLayoutFile = controllerLayout->getAttr("file");
  333.  
  334.         if (!strcmp(szLayoutName, "") || !strcmp(szLayoutFile, ""))
  335.                 return false;
  336.  
  337.         string layoutPath;
  338.         layoutPath.Format("libs/config/controller/%s", szLayoutFile);
  339.  
  340.         XmlNodeRef rootNode = GetISystem()->LoadXmlFromFile(layoutPath);
  341.         if (!rootNode)
  342.         {
  343.                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMapManager::PreloadControllerLayout: Failed to load xmlfile: %s", layoutPath.c_str());
  344.                 return false;
  345.         }
  346.  
  347.         m_preloadedControllerLayouts[szLayoutName] = rootNode;
  348.  
  349.         return true;
  350. }
  351.  
  352. bool CActionMapManager::LoadControllerLayoutFile(const char* szLayoutKeyName)
  353. {
  354.         CRY_ASSERT(szLayoutKeyName != NULL);
  355.  
  356.         TControllerLayouts::const_iterator iter = m_preloadedControllerLayouts.find(szLayoutKeyName);
  357.         if (iter == m_preloadedControllerLayouts.end())
  358.         {
  359.                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMapManager::LoadControllerLayoutFile: Failed to find preloaded controller layout for key: %s", szLayoutKeyName);
  360.                 return false;
  361.         }
  362.  
  363.         XmlNodeRef rootNode = iter->second;
  364.         CRY_ASSERT(rootNode != NULL);
  365.  
  366.         if (!LoadRebindDataFromXML(rootNode))
  367.         {
  368.                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMapManager::LoadControllerLayoutFile: Failed to load controller layout: %s", szLayoutKeyName);
  369.                 return false;
  370.         }
  371.  
  372.         return true;
  373. }
  374.  
  375. //------------------------------------------------------------------------
  376. bool CActionMapManager::LoadRebindDataFromXML(const XmlNodeRef& node)
  377. {
  378.         int ignoreVersion = 0;
  379.         node->getAttr("ignoreVersion", ignoreVersion);
  380.  
  381.         if (ignoreVersion == 0)
  382.         {
  383.                 int version = -1;
  384.                 if (node->getAttr("version", version))
  385.                 {
  386.                         if (version != m_version)
  387.                         {
  388.                                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMapManager::LoadRebindDataFromXML: Failed, version found %d -> required %d", version, m_version);
  389.                                 return false;
  390.                         }
  391.                 }
  392.                 else
  393.                 {
  394.                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMapManager::LoadRebindDataFromXML: Failed, obsolete action map format - version info is missing");
  395.                         return false;
  396.                 }
  397.         }
  398.  
  399.         //      load action maps
  400.         int nChildren = node->getChildCount();
  401.         for (int i = 0; i < nChildren; ++i)
  402.         {
  403.                 XmlNodeRef child = node->getChild(i);
  404.                 if (!strcmp(child->getTag(), "actionmap"))
  405.                 {
  406.                         const char* actionMapName = child->getAttr("name");
  407.                         IActionMap* pActionMap = GetActionMap(actionMapName);
  408.                         if (!pActionMap)
  409.                         {
  410.                                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMapManager::LoadRebindDataFromXML: Failed to find actionmap: %s", actionMapName);
  411.                                 continue;
  412.                         }
  413.  
  414.                         bool bResult = pActionMap->LoadRebindingDataFromXML(child);
  415.                         if (!bResult)
  416.                         {
  417.                                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMapManager::LoadRebindDataFromXML: Failed to load rebind data for actionmap: %s", actionMapName);
  418.                                 continue;
  419.                         }
  420.                 }
  421.         }
  422.  
  423.         return true;
  424. }
  425.  
  426. //------------------------------------------------------------------------
  427. bool CActionMapManager::SaveRebindDataToXML(XmlNodeRef& node)
  428. {
  429.         node->setAttr("version", m_version);
  430.         TActionMapMap::iterator iter = m_actionMaps.begin();
  431.         TActionMapMap::iterator iterEnd = m_actionMaps.end();
  432.         for (; iter != iterEnd; ++iter)
  433.         {
  434.                 CActionMap* pActionMap = iter->second;
  435.                 CRY_ASSERT(pActionMap != NULL);
  436.  
  437.                 if (pActionMap->GetNumRebindedInputs() == 0)
  438.                         continue;
  439.  
  440.                 XmlNodeRef child = node->newChild("actionmap");
  441.                 bool bResult = pActionMap->SaveRebindingDataToXML(child);
  442.                 if (!bResult)
  443.                 {
  444.                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMapManager::SaveRebindDataToXML: Failed to save rebind data for actionmap: %s", pActionMap->GetName());
  445.                 }
  446.         }
  447.  
  448.         return true;
  449. }
  450.  
  451. //------------------------------------------------------------------------
  452. bool CActionMapManager::AddExtraActionListener(IActionListener* pExtraActionListener, const char* actionMap)
  453. {
  454.         if ((actionMap != NULL) && (actionMap[0] != '\0'))
  455.         {
  456.                 TActionMapMap::iterator iActionMap = m_actionMaps.find(CONST_TEMP_STRING(actionMap));
  457.                 if (iActionMap != m_actionMaps.end())
  458.                 {
  459.                         iActionMap->second->AddExtraActionListener(pExtraActionListener);
  460.                         return true;
  461.                 }
  462.                 else
  463.                 {
  464.                         return false;
  465.                 }
  466.         }
  467.         else
  468.         {
  469.                 stl::push_back_unique(m_ExtraActionListeners, pExtraActionListener);
  470.                 return true;
  471.         }
  472. }
  473.  
  474. //------------------------------------------------------------------------
  475. bool CActionMapManager::RemoveExtraActionListener(IActionListener* pExtraActionListener, const char* actionMap)
  476. {
  477.         if ((actionMap != NULL) && (actionMap[0] != '\0'))
  478.         {
  479.                 TActionMapMap::iterator iActionMap = m_actionMaps.find(CONST_TEMP_STRING(actionMap));
  480.                 if (iActionMap != m_actionMaps.end())
  481.                 {
  482.                         iActionMap->second->RemoveExtraActionListener(pExtraActionListener);
  483.                         return true;
  484.                 }
  485.                 else
  486.                 {
  487.                         return false;
  488.                 }
  489.         }
  490.         else
  491.         {
  492.                 stl::find_and_erase(m_ExtraActionListeners, pExtraActionListener);
  493.                 return true;
  494.         }
  495. }
  496.  
  497. //------------------------------------------------------------------------
  498. const TActionListeners& CActionMapManager::GetExtraActionListeners() const
  499. {
  500.         return m_ExtraActionListeners;
  501. }
  502.  
  503. //------------------------------------------------------------------------
  504. bool CActionMapManager::AddFlowgraphNodeActionListener(IActionListener* pFlowgraphNodeActionListener, const char* actionMap)
  505. {
  506.         if ((actionMap != NULL) && (actionMap[0] != '\0'))
  507.         {
  508.                 TActionMapMap::iterator iActionMap = m_actionMaps.find(CONST_TEMP_STRING(actionMap));
  509.                 if(iActionMap != m_actionMaps.end())
  510.                 {
  511.                         iActionMap->second->AddFlowNodeActionListener(pFlowgraphNodeActionListener);
  512.                         return true;
  513.                 }
  514.                 else
  515.                 {
  516.                         return false;
  517.                 }
  518.         }
  519.         else
  520.         {
  521.                 stl::push_back_unique(m_ExtraActionListeners, pFlowgraphNodeActionListener);
  522.                 return true;
  523.         }
  524. }
  525.  
  526. //------------------------------------------------------------------------
  527. bool CActionMapManager::RemoveFlowgraphNodeActionListener(IActionListener* pFlowgraphNodeActionListener, const char* actionMap)
  528. {
  529.         if ((actionMap != NULL) && (actionMap[0] != '\0'))
  530.         {
  531.                 TActionMapMap::iterator iActionMap = m_actionMaps.find(CONST_TEMP_STRING(actionMap));
  532.                 if(iActionMap != m_actionMaps.end())
  533.                 {
  534.                         iActionMap->second->RemoveFlowNodeActionListener(pFlowgraphNodeActionListener);
  535.                         return true;
  536.                 }
  537.                 else
  538.                 {
  539.                         return false;
  540.                 }
  541.         }
  542.         else
  543.         {
  544.                 stl::find_and_erase(m_ExtraActionListeners, pFlowgraphNodeActionListener);
  545.                 return true;
  546.         }
  547. }
  548.  
  549. //------------------------------------------------------------------------
  550. void CActionMapManager::AddAlwaysActionListener(TBlockingActionListener pActionListener)
  551. {
  552.         // Don't add if already exists
  553.         TBlockingActionListeners::const_iterator iter = std::find(m_alwaysActionListeners.begin(), m_alwaysActionListeners.end(), pActionListener);
  554.         if (iter != m_alwaysActionListeners.end())
  555.                 return;
  556.  
  557.         m_alwaysActionListeners.push_back(TBlockingActionListener(pActionListener));
  558. }
  559.  
  560. //------------------------------------------------------------------------
  561. void CActionMapManager::RemoveAlwaysActionListener(TBlockingActionListener pActionListener)
  562. {
  563.         TBlockingActionListeners::iterator iter = std::find(m_alwaysActionListeners.begin(), m_alwaysActionListeners.end(), pActionListener);
  564.         if (iter == m_alwaysActionListeners.end())
  565.                 return;
  566.  
  567.         m_alwaysActionListeners.erase(iter);
  568. }
  569.  
  570. //------------------------------------------------------------------------
  571. void CActionMapManager::RemoveAllAlwaysActionListeners()
  572. {
  573.         m_alwaysActionListeners.clear();
  574. }
  575.  
  576. //------------------------------------------------------------------------
  577. IActionMap* CActionMapManager::CreateActionMap(const char* name)
  578. {
  579.         if (GetActionMap(name) != NULL)
  580.         {
  581.                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMapManager::CreateActionMap: Failed to create actionmap: %s, already exists", name);
  582.                 return NULL;
  583.         }
  584.  
  585.         CActionMap* pActionMap = new CActionMap(this, name);
  586.         if (pActionMap && (m_defaultEntityId != INVALID_ENTITYID))
  587.         {
  588.                 pActionMap->SetActionListener(m_defaultEntityId);
  589.         }
  590.  
  591.         m_actionMaps.insert(TActionMapMap::value_type(name, pActionMap));
  592.         return pActionMap;
  593. }
  594.  
  595. //------------------------------------------------------------------------
  596. bool CActionMapManager::RemoveActionMap(const char* name)
  597. {
  598.         TActionMapMap::iterator it = m_actionMaps.find(CONST_TEMP_STRING(name));
  599.         if (it == m_actionMaps.end())
  600.                 return false;
  601.  
  602.         CActionMap* pActionMap = it->second;
  603.         CRY_ASSERT(pActionMap != NULL);
  604.  
  605.         RemoveBind(pActionMap);
  606.  
  607.         SAFE_DELETE(pActionMap);
  608.         m_actionMaps.erase(it);
  609.  
  610.         return true;
  611. }
  612.  
  613. //------------------------------------------------------------------------
  614. void CActionMapManager::RemoveAllActionMaps()
  615. {
  616.         TActionMapMap::iterator actionMapit = m_actionMaps.begin();
  617.         TActionMapMap::iterator actionMapitEnd = m_actionMaps.end();
  618.         for (; actionMapit != actionMapitEnd; ++actionMapit)
  619.         {
  620.                 CActionMap* pActionMap = actionMapit->second;
  621.                 CRY_ASSERT(pActionMap != NULL);
  622.                 SAFE_DELETE(pActionMap);
  623.         }
  624.         m_actionMaps.clear();
  625.         m_inputCRCToBind.clear();
  626.  
  627.         RemoveAllRefireData();
  628. }
  629.  
  630. //------------------------------------------------------------------------
  631. void CActionMapManager::RemoveAllFilters()
  632. {
  633.         TActionFilterMap::iterator filtersIt = m_actionFilters.begin();
  634.         TActionFilterMap::iterator filtersItEnd = m_actionFilters.end();
  635.         for (; filtersIt != filtersItEnd; ++filtersIt)
  636.         {
  637.                 CActionFilter* pFilter = filtersIt->second;
  638.                 CRY_ASSERT(pFilter != NULL);
  639.                 SAFE_DELETE(pFilter);
  640.         }
  641.         m_actionFilters.clear();
  642. }
  643.  
  644. //------------------------------------------------------------------------
  645. IActionMap* CActionMapManager::GetActionMap(const char* name)
  646. {
  647.         TActionMapMap::iterator it = m_actionMaps.find(CONST_TEMP_STRING(name));
  648.         if (it == m_actionMaps.end())
  649.         {
  650.                 return NULL;
  651.         }
  652.         else
  653.         {
  654.                 return it->second;
  655.         }
  656. }
  657.  
  658. //------------------------------------------------------------------------
  659. const IActionMap* CActionMapManager::GetActionMap(const char* name) const
  660. {
  661.         TActionMapMap::const_iterator it = m_actionMaps.find(CONST_TEMP_STRING(name));
  662.         if (it == m_actionMaps.end())
  663.                 return NULL;
  664.         else
  665.                 return it->second;
  666. }
  667.  
  668. //------------------------------------------------------------------------
  669. IActionFilter* CActionMapManager::CreateActionFilter(const char* name, EActionFilterType type)
  670. {
  671.         IActionFilter* pActionFilter = GetActionFilter(name);
  672.         if (pActionFilter)
  673.                 return NULL;
  674.  
  675.         CActionFilter* pFilter = new CActionFilter(this, m_pInput, name, type);
  676.         m_actionFilters.insert(TActionFilterMap::value_type(name, pFilter));
  677.  
  678.         return pFilter;
  679. }
  680.  
  681. //------------------------------------------------------------------------
  682. IActionFilter* CActionMapManager::GetActionFilter(const char* name)
  683. {
  684.         TActionFilterMap::iterator it = m_actionFilters.find(CONST_TEMP_STRING(name));
  685.         if (it != m_actionFilters.end())
  686.         {
  687.                 return it->second;
  688.         }
  689.  
  690.         return NULL;
  691. }
  692.  
  693. //------------------------------------------------------------------------
  694. void CActionMapManager::Enable(const bool enable, const bool resetStateOnDisable)
  695. {
  696.         m_enabled = enable;
  697.  
  698.         if (!enable && resetStateOnDisable)
  699.         {
  700.                 TActionMapMap::iterator it = m_actionMaps.begin();
  701.                 TActionMapMap::iterator itEnd = m_actionMaps.end();
  702.                 for (; it != itEnd; ++it)
  703.                 {
  704.                         CActionMap* pActionMap = it->second;
  705.                         CRY_ASSERT(pActionMap != NULL);
  706.                         pActionMap->ReleaseActionsIfActive(); // Releases pressed held state
  707.  
  708.                         // Also need to clear repeat data
  709.                         RemoveAllRefireData();
  710.                 }
  711.         }
  712. }
  713.  
  714. //------------------------------------------------------------------------
  715. void CActionMapManager::EnableActionMap(const char* name, bool enable)
  716. {
  717.         if (name == 0 || *name == 0)
  718.         {
  719.                 TActionMapMap::iterator it = m_actionMaps.begin();
  720.                 TActionMapMap::iterator itEnd = m_actionMaps.end();
  721.                 while (it != itEnd)
  722.                 {
  723.                         it->second->Enable(enable);
  724.                         ++it;
  725.                 }
  726.         }
  727.         else
  728.         {
  729.                 TActionMapMap::iterator it = m_actionMaps.find(CONST_TEMP_STRING(name));
  730.  
  731.                 if (it != m_actionMaps.end())
  732.                 {
  733.                         if (it->second->Enabled() != enable)
  734.                         {
  735.                                 it->second->Enable(enable);
  736.                                 ReleaseFilteredActions();
  737.                                 BroadcastActionMapEvent(SActionMapEvent(SActionMapEvent::eActionMapManagerEvent_ActionMapStatusChanged, (UINT_PTR)it->second, (UINT_PTR)enable));
  738.                         }
  739.                 }
  740.         }
  741. }
  742.  
  743. //------------------------------------------------------------------------
  744. void CActionMapManager::EnableFilter(const char* name, bool enable)
  745. {
  746.         if (name == 0 || *name == 0)
  747.         {
  748.                 TActionFilterMap::iterator it = m_actionFilters.begin();
  749.                 TActionFilterMap::iterator itEnd = m_actionFilters.end();
  750.                 while (it != itEnd)
  751.                 {
  752.                         it->second->Enable(enable);
  753.                         ++it;
  754.                 }
  755.         }
  756.         else
  757.         {
  758.                 TActionFilterMap::iterator it = m_actionFilters.find(CONST_TEMP_STRING(name));
  759.  
  760.                 if (it != m_actionFilters.end())
  761.                 {
  762.                         if (it->second->Enabled() != enable)
  763.                         {
  764.                                 it->second->Enable(enable);
  765.                                 ReleaseFilteredActions();
  766.                                 BroadcastActionMapEvent(SActionMapEvent(SActionMapEvent::eActionMapManagerEvent_FilterStatusChanged, (UINT_PTR)name, (UINT_PTR)enable));
  767.                         }
  768.                 }
  769.         }
  770. }
  771.  
  772. //------------------------------------------------------------------------
  773. void CActionMapManager::ReleaseFilteredActions()
  774. {
  775.         for (TActionMapMap::iterator it = m_actionMaps.begin(), eit = m_actionMaps.end(); it != eit; ++it)
  776.         {
  777.                 if (it->second->Enabled())
  778.                 {
  779.                         it->second->ReleaseFilteredActions();
  780.                 }
  781.         }
  782. }
  783.  
  784. //------------------------------------------------------------------------
  785. void CActionMapManager::ClearStoredCurrentInputData()
  786. {
  787.         m_currentInputKeyID = eKI_Unknown;
  788.         m_bIncomingInputRepeated = false;
  789. }
  790.  
  791. //------------------------------------------------------------------------
  792. bool CActionMapManager::ReBindActionInput(const char* actionMapName, const ActionId& actionId, const char* szCurrentInput, const char* szNewInput)
  793. {
  794.         IActionMap* pActionMap = GetActionMap(actionMapName);
  795.         if (pActionMap)
  796.         {
  797.                 return pActionMap->ReBindActionInput(actionId, szCurrentInput, szNewInput);
  798.         }
  799.  
  800.         GameWarning("CActionMapManager::ReBindActionInput: Failed to find actionmap: %s", actionMapName);
  801.         return false;
  802. }
  803.  
  804. //------------------------------------------------------------------------
  805. const SActionInput* CActionMapManager::GetActionInput(const char* actionMapName, const ActionId& actionId, const EActionInputDevice device, const int iByDeviceIndex) const
  806. {
  807.         const IActionMap* pActionMap = GetActionMap(actionMapName);
  808.         if (!pActionMap)
  809.         {
  810.                 GameWarning("CActionMapManager::GetActionInput: Failed to find actionmap: %s", actionMapName);
  811.                 return NULL;
  812.         }
  813.  
  814.         const IActionMapAction* pActionMapAction = pActionMap->GetAction(actionId);
  815.         if (!pActionMapAction)
  816.         {
  817.                 GameWarning("CActionMapManager::GetActionInput: Failed to find action:%s in actionmap: %s", actionId.c_str(), actionMapName);
  818.                 return NULL;
  819.         }
  820.  
  821.         const SActionInput* pActionInput = pActionMapAction->GetActionInput(device, iByDeviceIndex);
  822.         if (!pActionInput)
  823.         {
  824.                 GameWarning("CActionMapManager::GetActionInput: Failed to find action input with deviceid: %d and index: %d, in action:%s in actionmap: %s", (int)device, iByDeviceIndex, actionId.c_str(), actionMapName);
  825.                 return NULL;
  826.         }
  827.  
  828.         return pActionInput;
  829. }
  830.  
  831. //------------------------------------------------------------------------
  832. bool CActionMapManager::IsFilterEnabled(const char* name)
  833. {
  834.         TActionFilterMap::iterator it = m_actionFilters.find(CONST_TEMP_STRING(name));
  835.  
  836.         if (it != m_actionFilters.end())
  837.         {
  838.                 return it->second->Enabled();
  839.         }
  840.  
  841.         return false;
  842. }
  843.  
  844. //------------------------------------------------------------------------
  845. bool CActionMapManager::ActionFiltered(const ActionId& action)
  846. {
  847.         for (TActionFilterMap::iterator it = m_actionFilters.begin(); it != m_actionFilters.end(); ++it)
  848.         {
  849.                 if (it->second->ActionFiltered(action))
  850.                 {
  851.                         return true;
  852.                 }
  853.         }
  854.  
  855.         return false;
  856. }
  857.  
  858. //------------------------------------------------------------------------
  859. bool CActionMapManager::CreateEventPriorityList(const SInputEvent& inputEvent, TBindPriorityList& priorityList)
  860. {
  861.         bool bRes = false;
  862.  
  863.         // Look up the actions which are associated with this
  864.         uint32 inputCRC = CCrc32::ComputeLowercase(inputEvent.keyName.c_str());
  865.         TInputCRCToBind::iterator itCRCBound = m_inputCRCToBind.lower_bound(inputCRC);
  866.         TInputCRCToBind::const_iterator itCRCBoundEnd = m_inputCRCToBind.end();
  867.  
  868.         // Create priority listing for which processes should be fired
  869.         float fLongestHeldTime = 0.0f;
  870.         for (; itCRCBound != itCRCBoundEnd && itCRCBound->first == inputCRC; ++itCRCBound)
  871.         {
  872.                 SBindData& bindData = itCRCBound->second;
  873.                 SActionInput* pActionInput = bindData.m_pActionInput;
  874.                 CRY_ASSERT(pActionInput != NULL);
  875.                 CActionMapAction* pAction = bindData.m_pAction;
  876.                 CRY_ASSERT(pAction != NULL);
  877.                 CActionMap* pActionMap = bindData.m_pActionMap;
  878.                 CRY_ASSERT(pActionMap != NULL);
  879.  
  880. #ifdef _DEBUG
  881.                 CRY_ASSERT((pActionInput->inputCRC == inputCRC) && (strcmp(pActionInput->input.c_str(), inputEvent.keyName.c_str()) == 0));
  882.  
  883.                 if ((pActionInput->inputCRC == inputCRC) && (strcmp(pActionInput->input.c_str(), inputEvent.keyName.c_str()) != 0))
  884.                 {
  885.                         GameWarning("Hash values are identical, but values are different! %s - %s", pActionInput->input.c_str(), inputEvent.keyName.c_str());
  886.                 }
  887.                 if ((pActionInput->inputCRC != inputCRC) && (strcmp(pActionInput->input.c_str(), inputEvent.keyName.c_str()) == 0))
  888.                 {
  889.                         GameWarning("Hash values are different, but values are identical! %s - %s", pActionInput->input.c_str(), inputEvent.keyName.c_str());
  890.                 }
  891.  
  892. #endif //_DEBUG
  893.  
  894.                 bool bAdd = (!ActionFiltered(pAction->GetActionId()) && pActionMap->CanProcessInput(inputEvent, pActionMap, pAction, pActionInput));
  895.  
  896.                 if (bAdd)
  897.                 {
  898.                         priorityList.push_back(&bindData);
  899.                         bRes = true;
  900.                 }
  901.         }
  902.  
  903.         return bRes;
  904. }
  905.  
  906. //------------------------------------------------------------------------
  907. bool CActionMapManager::ProcessAlwaysListeners(const ActionId& action, int activationMode, float value, const SInputEvent& inputEvent)
  908. {
  909.         TBlockingActionListeners::iterator iter = m_alwaysActionListeners.begin();
  910.         TBlockingActionListeners::iterator iterEnd = m_alwaysActionListeners.end();
  911.  
  912.         bool bHandled = false;
  913.         for (; iter != iterEnd; ++iter)
  914.         {
  915.                 TBlockingActionListener& listener = *iter;
  916.                 bHandled = listener->OnAction(action, activationMode, value, inputEvent);
  917.                 if (bHandled)
  918.                 {
  919.                         break;
  920.                 }
  921.         }
  922.  
  923.         return bHandled;
  924. }
  925.  
  926. //------------------------------------------------------------------------
  927. void CActionMapManager::RemoveBind(CActionMap* pActionMap)
  928. {
  929.         for (TInputCRCToBind::iterator iter = m_inputCRCToBind.begin(); iter != m_inputCRCToBind.end(); )
  930.         {
  931.                 SBindData* pBindData = &((*iter).second);
  932.                 if (pBindData->m_pActionMap == pActionMap)
  933.                 {
  934.                         TInputCRCToBind::iterator iterDelete = iter++;
  935.                         m_inputCRCToBind.erase(iterDelete);
  936.                 }
  937.                 else
  938.                 {
  939.                         ++iter;
  940.                 }
  941.         }
  942.  
  943.         RemoveRefireData(pActionMap);
  944. }
  945.  
  946. //------------------------------------------------------------------------
  947. void CActionMapManager::RemoveBind(CActionMapAction* pAction)
  948. {
  949.         for (TInputCRCToBind::iterator iter = m_inputCRCToBind.begin(); iter != m_inputCRCToBind.end(); )
  950.         {
  951.                 SBindData* pBindData = &((*iter).second);
  952.                 if (pBindData->m_pAction == pAction)
  953.                 {
  954.                         TInputCRCToBind::iterator iterDelete = iter++;
  955.                         m_inputCRCToBind.erase(iterDelete);
  956.                 }
  957.                 else
  958.                 {
  959.                         ++iter;
  960.                 }
  961.         }
  962.  
  963.         RemoveRefireData(pAction);
  964. }
  965.  
  966. //------------------------------------------------------------------------
  967. void CActionMapManager::RemoveActionFilter(CActionFilter* pActionFilter)
  968. {
  969.         for (TActionFilterMap::iterator it = m_actionFilters.begin(); it != m_actionFilters.end(); ++it)
  970.         {
  971.                 if (it->second == pActionFilter)
  972.                 {
  973.                         m_actionFilters.erase(it);
  974.  
  975.                         return;
  976.                 }
  977.         }
  978. }
  979.  
  980. //------------------------------------------------------------------------
  981. void CActionMapManager::ReleaseActionIfActive(const ActionId& actionId)
  982. {
  983.         TActionMapMap::iterator it = m_actionMaps.begin();
  984.         TActionMapMap::const_iterator end = m_actionMaps.end();
  985.         for (; it != end; ++it)
  986.         {
  987.                 it->second->ReleaseActionIfActive(actionId);
  988.         }
  989. }
  990. //------------------------------------------------------------------------
  991. bool CActionMapManager::AddBind(CActionMap* pActionMap, CActionMapAction* pAction, SActionInput* pActionInput)
  992. {
  993.         if (pActionInput->inputCRC == 0)
  994.         {
  995.                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMapManager::AddBind: Failed to add, missing crc value");
  996.                 return false;
  997.         }
  998.  
  999.         SBindData* pBindData = GetBindData(pActionMap, pAction, pActionInput);
  1000.         if (pBindData != NULL)
  1001.         {
  1002.                 pActionInput->inputCRC = 0;
  1003.                 CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMapManager::AddBind: Failed to add, already exists");
  1004.                 return false;
  1005.         }
  1006.  
  1007.         SBindData bindData(pActionMap, pAction, pActionInput);
  1008.  
  1009.         m_inputCRCToBind.insert(std::pair<uint32, SBindData>(pActionInput->inputCRC, bindData));
  1010.  
  1011.         return true;
  1012. }
  1013.  
  1014. //------------------------------------------------------------------------
  1015. bool CActionMapManager::RemoveBind(CActionMap* pActionMap, CActionMapAction* pAction, SActionInput* pActionInput)
  1016. {
  1017.         uint32 inputCRC = pActionInput->inputCRC;
  1018.  
  1019.         TInputCRCToBind::iterator iter = m_inputCRCToBind.lower_bound(inputCRC);
  1020.         TInputCRCToBind::const_iterator end = m_inputCRCToBind.end();
  1021.  
  1022.         for (; iter != end && iter->first == inputCRC; ++iter)
  1023.         {
  1024.                 SBindData& bindData = iter->second;
  1025.  
  1026.                 if (bindData.m_pActionMap == pActionMap && bindData.m_pAction == pAction && bindData.m_pActionInput->input == pActionInput->input)
  1027.                 {
  1028.                         m_inputCRCToBind.erase(iter);
  1029.                         RemoveRefireData(pActionMap, pAction, pActionInput);
  1030.                         return true;
  1031.                 }
  1032.         }
  1033.  
  1034.         return false;
  1035. }
  1036.  
  1037. //------------------------------------------------------------------------
  1038. bool CActionMapManager::HasBind(CActionMap* pActionMap, CActionMapAction* pAction, SActionInput* pActionInput) const
  1039. {
  1040.         uint32 inputCRC = pActionInput->inputCRC;
  1041.  
  1042.         TInputCRCToBind::const_iterator iter = m_inputCRCToBind.lower_bound(inputCRC);
  1043.         TInputCRCToBind::const_iterator end = m_inputCRCToBind.end();
  1044.  
  1045.         for (; iter != end && iter->first == inputCRC; ++iter)
  1046.         {
  1047.                 const SBindData& bindData = iter->second;
  1048.  
  1049.                 if (bindData.m_pActionMap == pActionMap && bindData.m_pAction == pAction && bindData.m_pActionInput->input == pActionInput->input)
  1050.                 {
  1051.                         return true;
  1052.                 }
  1053.         }
  1054.  
  1055.         return false;
  1056. }
  1057.  
  1058. //------------------------------------------------------------------------
  1059. bool CActionMapManager::UpdateRefireData(const SInputEvent& event, CActionMap* pActionMap, CActionMapAction* pAction, SActionInput* pActionInput)
  1060. {
  1061.         SRefireData* pRefireData = NULL;
  1062.         TInputCRCToRefireData::iterator iter = m_inputCRCToRefireData.find(pActionInput->inputCRC);
  1063.         if (iter != m_inputCRCToRefireData.end())
  1064.         {
  1065.                 pRefireData = iter->second;
  1066.                 CRY_ASSERT(pRefireData != NULL);
  1067.  
  1068.                 // Search if match exists
  1069.                 SRefireBindData* pFoundBindData = NULL;
  1070.                 TRefireBindData& refireBindData = pRefireData->m_refireBindData;
  1071.                 TRefireBindData::iterator refireBindDataIt = refireBindData.begin();
  1072.                 TRefireBindData::const_iterator refireBindDataItEnd = refireBindData.end();
  1073.                 for (; refireBindDataIt != refireBindDataItEnd; ++refireBindDataIt)
  1074.                 {
  1075.                         SRefireBindData& singleRefireBindData = *refireBindDataIt;
  1076.                         SBindData& bindData = singleRefireBindData.m_bindData;
  1077.                         if (bindData.m_pActionMap == pActionMap && bindData.m_pAction == pAction && bindData.m_pActionInput == pActionInput)
  1078.                         {
  1079.                                 pFoundBindData = &singleRefireBindData;
  1080.                         }
  1081.                 }
  1082.  
  1083.                 if (pFoundBindData) // Just update input since analog value could have changed or delayed press needing a release
  1084.                 {
  1085.                         pRefireData->m_inputEvent = event;
  1086.                         pFoundBindData->m_bIgnoreNextUpdate = true;
  1087.                 }
  1088.                 else
  1089.                 {
  1090.                         refireBindData.push_back(SRefireBindData(pActionMap, pAction, pActionInput));
  1091.                         refireBindData[refireBindData.size() - 1].m_bIgnoreNextUpdate = true;
  1092.                 }
  1093.         }
  1094.         else
  1095.         {
  1096.                 pRefireData = new SRefireData(event, pActionMap, pAction, pActionInput);
  1097.                 CRY_ASSERT(pRefireData->m_refireBindData.empty() == false);
  1098.                 pRefireData->m_refireBindData[0].m_bIgnoreNextUpdate = true;
  1099.                 m_inputCRCToRefireData.insert(std::pair<uint32, SRefireData*>(pActionInput->inputCRC, pRefireData));
  1100.         }
  1101.  
  1102.         return true;
  1103. }
  1104.  
  1105. //------------------------------------------------------------------------
  1106. bool CActionMapManager::RemoveRefireData(CActionMap* pActionMap, CActionMapAction* pAction, SActionInput* pActionInput)
  1107. {
  1108.         CRY_ASSERT(m_bRefiringInputs == false); // This should never happen
  1109.  
  1110.         uint32 inputCRC = pActionInput->inputCRC;
  1111.         if (inputCRC == 0)
  1112.                 return false;
  1113.  
  1114.         TInputCRCToRefireData::iterator iter = m_inputCRCToRefireData.find(inputCRC);
  1115.         if (iter == m_inputCRCToRefireData.end())
  1116.                 return false;
  1117.  
  1118.         SRefireData* pRefireData = iter->second;
  1119.         CRY_ASSERT(pRefireData != NULL);
  1120.  
  1121.         // Try to find the actual match now, just finding the crc, doesn't mean this action input is here
  1122.  
  1123.         TRefireBindData& refireBindData = pRefireData->m_refireBindData;
  1124.         TRefireBindData::iterator refireBindDataIt = refireBindData.begin();
  1125.         TRefireBindData::const_iterator refireBindDataItEnd = refireBindData.end();
  1126.         for (; refireBindDataIt != refireBindDataItEnd; ++refireBindDataIt)
  1127.         {
  1128.                 SRefireBindData& singleRefireBindData = *refireBindDataIt;
  1129.                 SBindData& bindData = singleRefireBindData.m_bindData;
  1130.                 if (bindData.m_pActionMap == pActionMap && bindData.m_pAction == pAction && bindData.m_pActionInput == pActionInput)
  1131.                 {
  1132.                         if (refireBindData.size() > 1) // Don't remove whole mapping, just this specific one
  1133.                         {
  1134.                                 refireBindData.erase(refireBindDataIt);
  1135.                         }
  1136.                         else // No other inputs mapped, remove whole mapping
  1137.                         {
  1138.                                 SAFE_DELETE(pRefireData);
  1139.                                 m_inputCRCToRefireData.erase(iter);
  1140.                         }
  1141.  
  1142.                         return true;
  1143.                 }
  1144.         }
  1145.  
  1146.         return false;
  1147. }
  1148.  
  1149. //------------------------------------------------------------------------
  1150. void CActionMapManager::RemoveRefireData(CActionMap* pActionMap)
  1151. {
  1152.         CRY_ASSERT(m_bRefiringInputs == false); // This should never happen
  1153.  
  1154.         TInputCRCToRefireData::iterator iter = m_inputCRCToRefireData.begin();
  1155.         TInputCRCToRefireData::iterator iterEnd = m_inputCRCToRefireData.end();
  1156.         while (iter != iterEnd)
  1157.         {
  1158.                 SRefireData* pRefireData = iter->second;
  1159.                 CRY_ASSERT(pRefireData != NULL);
  1160.  
  1161.                 TRefireBindData& refireBindData = pRefireData->m_refireBindData;
  1162.                 TRefireBindData::iterator refireBindDataIt = refireBindData.begin();
  1163.                 TRefireBindData::const_iterator refireBindDataItEnd = refireBindData.end();
  1164.                 while (refireBindDataIt != refireBindDataItEnd)
  1165.                 {
  1166.                         SRefireBindData& singleRefireBindData = *refireBindDataIt;
  1167.                         SBindData& bindData = singleRefireBindData.m_bindData;
  1168.                         if (bindData.m_pActionMap == pActionMap)
  1169.                         {
  1170.                                 TRefireBindData::iterator iterDelete = refireBindDataIt++;
  1171.                                 refireBindData.erase(iterDelete);
  1172.                         }
  1173.                         else
  1174.                         {
  1175.                                 ++refireBindDataIt;
  1176.                         }
  1177.                 }
  1178.  
  1179.                 if (refireBindData.empty()) // Remove whole mapping if no more items exist for the input
  1180.                 {
  1181.                         SAFE_DELETE(pRefireData);
  1182.                         TInputCRCToRefireData::iterator iterDelete = iter++;
  1183.                         m_inputCRCToRefireData.erase(iterDelete);
  1184.                 }
  1185.                 else
  1186.                 {
  1187.                         ++iter;
  1188.                 }
  1189.         }
  1190. }
  1191.  
  1192. //------------------------------------------------------------------------
  1193. void CActionMapManager::RemoveRefireData(CActionMapAction* pAction)
  1194. {
  1195.         CRY_ASSERT(m_bRefiringInputs == false); // This should never happen
  1196.  
  1197.         TInputCRCToRefireData::iterator iter = m_inputCRCToRefireData.begin();
  1198.         TInputCRCToRefireData::iterator iterEnd = m_inputCRCToRefireData.end();
  1199.         while (iter != iterEnd)
  1200.         {
  1201.                 SRefireData* pRefireData = iter->second;
  1202.                 CRY_ASSERT(pRefireData != NULL);
  1203.  
  1204.                 TRefireBindData& refireBindData = pRefireData->m_refireBindData;
  1205.                 TRefireBindData::iterator refireBindDataIt = refireBindData.begin();
  1206.                 TRefireBindData::const_iterator refireBindDataItEnd = refireBindData.end();
  1207.                 while (refireBindDataIt != refireBindDataItEnd)
  1208.                 {
  1209.                         SRefireBindData& singleRefireBindData = *refireBindDataIt;
  1210.                         SBindData& bindData = singleRefireBindData.m_bindData;
  1211.                         if (bindData.m_pAction == pAction)
  1212.                         {
  1213.                                 TRefireBindData::iterator iterDelete = refireBindDataIt++;
  1214.                                 refireBindData.erase(iterDelete);
  1215.                         }
  1216.                         else
  1217.                         {
  1218.                                 ++refireBindDataIt;
  1219.                         }
  1220.                 }
  1221.  
  1222.                 if (refireBindData.empty()) // Remove whole mapping if no more items exist for the input
  1223.                 {
  1224.                         SAFE_DELETE(pRefireData);
  1225.                         TInputCRCToRefireData::iterator iterDelete = iter++;
  1226.                         m_inputCRCToRefireData.erase(iterDelete);
  1227.                 }
  1228.                 else
  1229.                 {
  1230.                         ++iter;
  1231.                 }
  1232.         }
  1233. }
  1234.  
  1235. //------------------------------------------------------------------------
  1236. void CActionMapManager::RemoveAllRefireData()
  1237. {
  1238.         if (!m_bRefiringInputs)
  1239.         {
  1240.                 TInputCRCToRefireData::iterator it = m_inputCRCToRefireData.begin();
  1241.                 TInputCRCToRefireData::iterator itEnd = m_inputCRCToRefireData.end();
  1242.                 for (; it != itEnd; ++it)
  1243.                 {
  1244.                         SRefireData* pRefireData = it->second;
  1245.                         CRY_ASSERT(pRefireData != NULL);
  1246.                         SAFE_DELETE(pRefireData);
  1247.                 }
  1248.  
  1249.                 m_inputCRCToRefireData.clear();
  1250.         }
  1251.         else // This can happen if disabling an action filter from refired input
  1252.         {
  1253.                 m_bDelayedRemoveAllRefiringData = true;
  1254.         }
  1255. }
  1256.  
  1257. //------------------------------------------------------------------------
  1258. void CActionMapManager::SetDefaultActionEntity(EntityId id, bool bUpdateAll)
  1259. {
  1260.         if (bUpdateAll)
  1261.         {
  1262.                 IActionMapIteratorPtr pActionMapIter = CreateActionMapIterator();
  1263.                 while (IActionMap* pActionMap = pActionMapIter->Next())
  1264.                 {
  1265.                         pActionMap->SetActionListener(id);
  1266.                 }
  1267.         }
  1268.  
  1269.         m_defaultEntityId = id;
  1270.  
  1271.         BroadcastActionMapEvent(SActionMapEvent(SActionMapEvent::eActionMapManagerEvent_DefaultActionEntityChanged, (UINT_PTR)id));
  1272. }
  1273.  
  1274. //------------------------------------------------------------------------
  1275. void CActionMapManager::RegisterActionMapEventListener(IActionMapEventListener* pActionMapEventListener)
  1276. {
  1277.         stl::push_back_unique(m_actionMapEventListeners, pActionMapEventListener);
  1278. }
  1279.  
  1280. //------------------------------------------------------------------------
  1281. void CActionMapManager::UnregisterActionMapEventListener(IActionMapEventListener* pActionMapEventListener)
  1282. {
  1283.         stl::find_and_erase(m_actionMapEventListeners, pActionMapEventListener);
  1284. }
  1285.  
  1286. //------------------------------------------------------------------------
  1287. void CActionMapManager::BroadcastActionMapEvent(const SActionMapEvent& event)
  1288. {
  1289.         if (!m_actionMapEventListeners.empty())
  1290.         {
  1291.                 CActionMapManager::TActionMapEventListeners::const_iterator iter = m_actionMapEventListeners.begin();
  1292.                 CActionMapManager::TActionMapEventListeners::const_iterator cur;
  1293.                 while (iter != m_actionMapEventListeners.end())
  1294.                 {
  1295.                         cur = iter++;
  1296.                         (*cur)->OnActionMapEvent(event);
  1297.                 }
  1298.         }
  1299. }
  1300.  
  1301. //------------------------------------------------------------------------
  1302. bool CActionMapManager::SetRefireDataDelayedPressNeedsRelease(const SInputEvent& event, CActionMap* pActionMap, CActionMapAction* pAction, SActionInput* pActionInput, const bool bDelayedPressNeedsRelease)
  1303. {
  1304.         TInputCRCToRefireData::iterator iter = m_inputCRCToRefireData.find(pActionInput->inputCRC);
  1305.         if (iter == m_inputCRCToRefireData.end())
  1306.                 return false;
  1307.  
  1308.         SRefireData* pRefireData = iter->second;
  1309.         CRY_ASSERT(pRefireData != NULL);
  1310.  
  1311.         // Search if match exists
  1312.         TRefireBindData& refireBindData = pRefireData->m_refireBindData;
  1313.         TRefireBindData::iterator refireBindDataIt = refireBindData.begin();
  1314.         TRefireBindData::const_iterator refireBindDataItEnd = refireBindData.end();
  1315.         for (; refireBindDataIt != refireBindDataItEnd; ++refireBindDataIt)
  1316.         {
  1317.                 SRefireBindData& singleRefireBindData = *refireBindDataIt;
  1318.                 SBindData& bindData = singleRefireBindData.m_bindData;
  1319.                 if (bindData.m_pActionMap == pActionMap && bindData.m_pAction == pAction && bindData.m_pActionInput == pActionInput)
  1320.                 {
  1321.                         singleRefireBindData.m_bDelayedPressNeedsRelease = bDelayedPressNeedsRelease;
  1322.                         return true;
  1323.                 }
  1324.         }
  1325.  
  1326.         return false;
  1327. }
  1328.  
  1329. //------------------------------------------------------------------------
  1330. void CActionMapManager::RemoveAllDelayedPressRefireData()
  1331. {
  1332.         CRY_ASSERT(m_bRefiringInputs == false); // This should never happen
  1333.  
  1334.         TInputCRCToRefireData::iterator iter = m_inputCRCToRefireData.begin();
  1335.         TInputCRCToRefireData::iterator iterEnd = m_inputCRCToRefireData.end();
  1336.  
  1337.         while (iter != iterEnd)
  1338.         {
  1339.                 SRefireData* pRefireData = iter->second;
  1340.                 CRY_ASSERT(pRefireData != NULL);
  1341.                 PREFAST_ASSUME(pRefireData != NULL);
  1342.                 if (pRefireData->m_inputEvent.state == eIS_Pressed)
  1343.                 {
  1344.                         TInputCRCToRefireData::iterator deleteIter = iter;
  1345.                         ++iter;
  1346.                         SAFE_DELETE(pRefireData);
  1347.                         m_inputCRCToRefireData.erase(deleteIter);
  1348.                 }
  1349.                 else
  1350.                 {
  1351.                         ++iter;
  1352.                 }
  1353.         }
  1354. }
  1355.  
  1356. //------------------------------------------------------------------------
  1357. int CActionMapManager::GetHighestPressDelayPriority() const
  1358. {
  1359.         int iHighestPressDelayPriority = -1;
  1360.         TInputCRCToRefireData::const_iterator iter = m_inputCRCToRefireData.begin();
  1361.         TInputCRCToRefireData::const_iterator iterEnd = m_inputCRCToRefireData.end();
  1362.  
  1363.         TRefireBindData::const_iterator refireBindIter;
  1364.         TRefireBindData::const_iterator refireBindIterEnd;
  1365.  
  1366.         for (; iter != iterEnd; ++iter)
  1367.         {
  1368.                 const SRefireData* pRefireData = iter->second;
  1369.                 CRY_ASSERT(pRefireData != NULL);
  1370.  
  1371.                 refireBindIter = pRefireData->m_refireBindData.begin();
  1372.                 refireBindIterEnd = pRefireData->m_refireBindData.end();
  1373.                 for (; refireBindIter != refireBindIterEnd; ++refireBindIter)
  1374.                 {
  1375.                         const SRefireBindData& refireBindData = *refireBindIter;
  1376.                         const SBindData& bindData = refireBindData.m_bindData;
  1377.                         const SActionInput* pActionInput = bindData.m_pActionInput;
  1378.                         CRY_ASSERT(pActionInput != NULL);
  1379.                         if (pActionInput->iPressDelayPriority > iHighestPressDelayPriority)
  1380.                         {
  1381.                                 iHighestPressDelayPriority = pActionInput->iPressDelayPriority;
  1382.                         }
  1383.                 }
  1384.         }
  1385.  
  1386.         return iHighestPressDelayPriority;
  1387. }
  1388.  
  1389. //------------------------------------------------------------------------
  1390. void CActionMapManager::ReloadActionMaps(IConsoleCmdArgs* pArgs)
  1391. {
  1392.         s_pThis->InitActionMaps(s_pThis->GetLoadFromXMLPath());
  1393. }
  1394.  
  1395. //------------------------------------------------------------------------
  1396. CActionMapManager::SBindData* CActionMapManager::GetBindData(CActionMap* pActionMap, CActionMapAction* pAction, SActionInput* pActionInput)
  1397. {
  1398.         SBindData* pFoundBindData = NULL;
  1399.         uint32 inputCRC = pActionInput->inputCRC;
  1400.         TInputCRCToBind::iterator iter = m_inputCRCToBind.lower_bound(inputCRC);
  1401.         TInputCRCToBind::const_iterator end = m_inputCRCToBind.end();
  1402.  
  1403.         for (; iter != end && iter->first == inputCRC; ++iter)
  1404.         {
  1405.                 SBindData& bindData = iter->second;
  1406.  
  1407.                 if (bindData.m_pActionMap == pActionMap && bindData.m_pAction == pAction && bindData.m_pActionInput->input == pActionInput->input)
  1408.                 {
  1409.                         pFoundBindData = &bindData;
  1410.                         break;
  1411.                 }
  1412.         }
  1413.  
  1414.         return pFoundBindData;
  1415. }
  1416.  
  1417. //------------------------------------------------------------------------
  1418.  
  1419. namespace
  1420. {
  1421. template<typename T, class Derived>
  1422. struct CGenericPtrMapIterator : public Derived
  1423. {
  1424.         typedef typename T::mapped_type MappedType;
  1425.         typedef typename T::iterator    IterType;
  1426.         CGenericPtrMapIterator(T& theMap)
  1427.                 : m_nRefs(0)
  1428.         {
  1429.                 m_cur = theMap.begin();
  1430.                 m_end = theMap.end();
  1431.         }
  1432.         virtual MappedType Next()
  1433.         {
  1434.                 if (m_cur == m_end)
  1435.                         return 0;
  1436.                 MappedType& dt = m_cur->second;
  1437.                 ++m_cur;
  1438.                 return dt;
  1439.         }
  1440.         virtual void AddRef()
  1441.         {
  1442.                 ++m_nRefs;
  1443.         }
  1444.         virtual void Release()
  1445.         {
  1446.                 if (--m_nRefs <= 0)
  1447.                         delete this;
  1448.         }
  1449.         IterType m_cur;
  1450.         IterType m_end;
  1451.         int      m_nRefs;
  1452. };
  1453. };
  1454.  
  1455. //------------------------------------------------------------------------
  1456. IActionMapIteratorPtr CActionMapManager::CreateActionMapIterator()
  1457. {
  1458.         return new CGenericPtrMapIterator<TActionMapMap, IActionMapIterator>(m_actionMaps);
  1459. }
  1460.  
  1461. //------------------------------------------------------------------------
  1462. IActionFilterIteratorPtr CActionMapManager::CreateActionFilterIterator()
  1463. {
  1464.         return new CGenericPtrMapIterator<TActionFilterMap, IActionFilterIterator>(m_actionFilters);
  1465. }
  1466.  
  1467. //------------------------------------------------------------------------
  1468. void CActionMapManager::EnumerateActions(IActionMapPopulateCallBack* pCallBack) const
  1469. {
  1470.         for (TActionMapMap::const_iterator actionMapIt = m_actionMaps.begin(); actionMapIt != m_actionMaps.end(); ++actionMapIt)
  1471.         {
  1472.                 actionMapIt->second->EnumerateActions(pCallBack);
  1473.         }
  1474. }
  1475.  
  1476. //------------------------------------------------------------------------
  1477. int CActionMapManager::GetActionsCount() const
  1478. {
  1479.         int actionCount = 0;
  1480.         for (TActionMapMap::const_iterator actionMapIt = m_actionMaps.begin(); actionMapIt != m_actionMaps.end(); ++actionMapIt)
  1481.         {
  1482.                 actionCount += actionMapIt->second->GetActionsCount();
  1483.         }
  1484.  
  1485.         return actionCount;
  1486. }
  1487.  
  1488. //------------------------------------------------------------------------
  1489. bool CActionMapManager::AddInputDeviceMapping(const EActionInputDevice deviceType, const char* szDeviceTypeStr)
  1490. {
  1491.         TInputDeviceData::iterator iter = m_inputDeviceData.begin();
  1492.         TInputDeviceData::iterator iterEnd = m_inputDeviceData.end();
  1493.         for (; iter != iterEnd; ++iter)
  1494.         {
  1495.                 SActionInputDeviceData& inputDeviceData = *iter;
  1496.                 if (inputDeviceData.m_type == deviceType)
  1497.                 {
  1498.                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMapManager::AddInputDeviceMapping: Device type already exists, failed to add device: %s", szDeviceTypeStr);
  1499.                         return false;
  1500.                 }
  1501.         }
  1502.  
  1503.         SActionInputDeviceData inputDeviceData(deviceType, szDeviceTypeStr);
  1504.         m_inputDeviceData.push_back(inputDeviceData);
  1505.  
  1506.         return true;
  1507. }
  1508.  
  1509. //------------------------------------------------------------------------
  1510. bool CActionMapManager::RemoveInputDeviceMapping(const EActionInputDevice deviceType)
  1511. {
  1512.         TInputDeviceData::iterator iter = m_inputDeviceData.begin();
  1513.         TInputDeviceData::iterator iterEnd = m_inputDeviceData.end();
  1514.         for (; iter != iterEnd; ++iter)
  1515.         {
  1516.                 SActionInputDeviceData& inputDeviceData = *iter;
  1517.                 if (inputDeviceData.m_type == deviceType)
  1518.                 {
  1519.                         m_inputDeviceData.erase(iter);
  1520.                         return true;
  1521.                 }
  1522.         }
  1523.  
  1524.         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CActionMapManager::RemoveInputDeviceMapping: Failed to find device");
  1525.         return false;
  1526. }
  1527.  
  1528. //------------------------------------------------------------------------
  1529. void CActionMapManager::ClearInputDevicesMappings()
  1530. {
  1531.         m_inputDeviceData.clear();
  1532. }
  1533.  
  1534. //------------------------------------------------------------------------
  1535. int CActionMapManager::GetNumInputDeviceData() const
  1536. {
  1537.         return m_inputDeviceData.size();
  1538. }
  1539.  
  1540. //------------------------------------------------------------------------
  1541. const SActionInputDeviceData* CActionMapManager::GetInputDeviceDataByIndex(const int iIndex)
  1542. {
  1543.         CRY_ASSERT(iIndex >= 0 && iIndex < m_inputDeviceData.size());
  1544.         if (iIndex < 0 || iIndex >= m_inputDeviceData.size())
  1545.                 return NULL;
  1546.  
  1547.         return &m_inputDeviceData[iIndex];
  1548. }
  1549.  
  1550. //------------------------------------------------------------------------
  1551. const SActionInputDeviceData* CActionMapManager::GetInputDeviceDataByType(const EActionInputDevice deviceType)
  1552. {
  1553.         SActionInputDeviceData* pFoundInputDeviceData = NULL;
  1554.  
  1555.         TInputDeviceData::iterator iter = m_inputDeviceData.begin();
  1556.         TInputDeviceData::iterator iterEnd = m_inputDeviceData.end();
  1557.         for (; iter != iterEnd; ++iter)
  1558.         {
  1559.                 SActionInputDeviceData& inputDeviceData = *iter;
  1560.                 if (inputDeviceData.m_type == deviceType)
  1561.                 {
  1562.                         pFoundInputDeviceData = &inputDeviceData;
  1563.                         break;
  1564.                 }
  1565.         }
  1566.  
  1567.         return pFoundInputDeviceData;
  1568. }
  1569.  
  1570. //------------------------------------------------------------------------
  1571. const SActionInputDeviceData* CActionMapManager::GetInputDeviceDataByType(const char* szDeviceType)
  1572. {
  1573.         SActionInputDeviceData* pFoundInputDeviceData = NULL;
  1574.  
  1575.         TInputDeviceData::iterator iter = m_inputDeviceData.begin();
  1576.         TInputDeviceData::iterator iterEnd = m_inputDeviceData.end();
  1577.         for (; iter != iterEnd; ++iter)
  1578.         {
  1579.                 SActionInputDeviceData& inputDeviceData = *iter;
  1580.                 if (strcmp(inputDeviceData.m_typeStr, szDeviceType) == 0)
  1581.                 {
  1582.                         pFoundInputDeviceData = &inputDeviceData;
  1583.                         break;
  1584.                 }
  1585.         }
  1586.  
  1587.         return pFoundInputDeviceData;
  1588. }
  1589.  
  1590. //------------------------------------------------------------------------
  1591. void CActionMapManager::GetMemoryStatistics(ICrySizer* pSizer)
  1592. {
  1593.         SIZER_SUBCOMPONENT_NAME(pSizer, "ActionMapManager");
  1594.         pSizer->AddObject(this, sizeof(*this));
  1595.         pSizer->AddObject(m_actionMaps);
  1596.         pSizer->AddObject(m_actionFilters);
  1597. }
  1598.  
  1599. //------------------------------------------------------------------------
  1600. bool CActionMapManager::HandleAcceptedEvents(const SInputEvent& event, TBindPriorityList& priorityList)
  1601. {
  1602.         float fCurrTime = gEnv->pTimer->GetCurrTime();
  1603.         IGameFramework* pGameFramework = gEnv->pGameFramework;
  1604.         if (pGameFramework && pGameFramework->IsGamePaused())
  1605.         {
  1606.                 fCurrTime = gEnv->pTimer->GetCurrTime(ITimer::ETIMER_UI);
  1607.         }
  1608.  
  1609.         TBindPriorityList::iterator itBind = priorityList.begin();
  1610.         TBindPriorityList::const_iterator itBindEnd = priorityList.end();
  1611.         for (; itBind != itBindEnd; ++itBind)
  1612.         {
  1613.                 const SBindData* pBindData = *itBind;
  1614.                 CRY_ASSERT(pBindData);
  1615.  
  1616.                 CActionMap* pActionMap = pBindData->m_pActionMap;
  1617.                 CRY_ASSERT(pActionMap != NULL);
  1618.  
  1619.                 if (!pActionMap->Enabled())
  1620.                         continue;
  1621.  
  1622.                 SActionInput* pActionInput = pBindData->m_pActionInput;
  1623.                 CRY_ASSERT(pActionInput != NULL);
  1624.  
  1625.                 const CActionMapAction* pAction = pBindData->m_pAction;
  1626.                 CRY_ASSERT(pAction != NULL);
  1627.  
  1628.                 const ActionId& actionID = pAction->GetActionId();
  1629.  
  1630.                 if (gEnv->pInput->Retriggering() && (!(pActionInput->activationMode & eAAM_Retriggerable)))
  1631.                         continue;
  1632.  
  1633.                 // Current action will fire below, check if actioninput blocks input and handle
  1634.                 HandleInputBlocking(event, pActionInput, fCurrTime);
  1635.  
  1636.                 EInputState currentState = pActionInput->currentState;
  1637.  
  1638.                 // Process console
  1639.                 if (pActionInput->activationMode & eAAM_ConsoleCmd)
  1640.                 {
  1641.                         CConsoleActionListener consoleActionListener;
  1642.                         consoleActionListener.OnAction(actionID, currentState, event.value);
  1643.  
  1644.                         const TActionListeners& extraActionListeners = GetExtraActionListeners();
  1645.                         for (TActionListeners::const_iterator extraListener = extraActionListeners.begin(); extraListener != extraActionListeners.end(); ++extraListener)
  1646.                                 (*extraListener)->OnAction(actionID, currentState, event.value);
  1647.  
  1648.                         return true;
  1649.                 }
  1650.  
  1651.                 pActionMap->NotifyFlowNodeActionListeners(actionID, currentState, event.value);
  1652.  
  1653.                 // TODO: Remove always action listeners and integrate into 1 prioritized type
  1654.                 // Process the always events first, then process normal if not handled
  1655.                 bool bHandled = ProcessAlwaysListeners(actionID, currentState, event.value, event);
  1656.                 if (bHandled)
  1657.                         continue;
  1658.  
  1659.                 const TActionListeners& extraActionListeners = GetExtraActionListeners();
  1660.                 for (TActionListeners::const_iterator extraListener = extraActionListeners.begin(); extraListener != extraActionListeners.end(); ++extraListener)
  1661.                         (*extraListener)->OnAction(actionID, currentState, event.value);
  1662.  
  1663.                 pActionMap->NotifyExtraActionListeners(actionID, currentState, event.value);
  1664.  
  1665.                 // Process normal events
  1666.                 IEntity* pEntity = gEnv->pEntitySystem->GetEntity(pActionMap->GetActionListener());
  1667.                 if (!pEntity)
  1668.                         continue;
  1669.  
  1670.                 CGameObject* pGameObject = (CGameObject*) pEntity->GetProxy(ENTITY_PROXY_USER);
  1671.                 if (!pGameObject)
  1672.                         continue;
  1673.  
  1674.                 pGameObject->OnAction(actionID, currentState, event.value);
  1675.         }
  1676.  
  1677.         return false; // Not handled
  1678. }
  1679.  
  1680. //------------------------------------------------------------------------
  1681. void CActionMapManager::HandleInputBlocking(const SInputEvent& event, const SActionInput* pActionInput, const float fCurrTime)
  1682. {
  1683.         // Refired events will make it here even when input blocked, handle these here
  1684.         if (IsCurrentlyRefiringInput())
  1685.         {
  1686.                 if (gEnv->pInput->ShouldBlockInputEventPosting(event.keyId, event.deviceType, event.deviceIndex))
  1687.                 {
  1688.                         return;
  1689.                 }
  1690.         }
  1691.  
  1692.         const SActionInputBlockData& inputBlockData = pActionInput->inputBlockData;
  1693.         EActionInputBlockType blockType = inputBlockData.blockType;
  1694.         if (blockType == eAIBT_None)
  1695.                 return;
  1696.  
  1697.         // Check if block condition fulfilled
  1698.  
  1699.         // This can be optimized once EInputState + EActionActivationMode are combined like it should be
  1700.         EInputState compareState;
  1701.  
  1702.         // Need to translate analog to press, down, release state for easy comparison
  1703.         if (event.state == eIS_Changed)
  1704.         {
  1705.                 if (pActionInput->bAnalogConditionFulfilled)
  1706.                 {
  1707.                         if (fCurrTime - pActionInput->fPressedTime >= FLT_EPSILON) // Can't be pressed since time has elapsed, must be hold
  1708.                         {
  1709.                                 compareState = eIS_Down;
  1710.                         }
  1711.                         else
  1712.                         {
  1713.                                 compareState = eIS_Pressed;
  1714.                         }
  1715.                 }
  1716.                 else // Must be release
  1717.                 {
  1718.                         compareState = eIS_Released;
  1719.                 }
  1720.         }
  1721.         else
  1722.         {
  1723.                 compareState = event.state;
  1724.         }
  1725.  
  1726.         if (compareState & inputBlockData.activationMode)
  1727.         {
  1728.                 switch (inputBlockData.blockType)
  1729.                 {
  1730.                 case eAIBT_BlockInputs:
  1731.                         {
  1732.                                 const TActionInputBlockers& inputs = inputBlockData.inputs;
  1733.                                 TActionInputBlockers::const_iterator iter = inputs.begin();
  1734.                                 TActionInputBlockers::const_iterator iterEnd = inputs.end();
  1735.                                 for (; iter != iterEnd; ++iter)
  1736.                                 {
  1737.                                         const SActionInputBlocker& inputToBlock = *iter;
  1738.                                         SInputBlockData inputDataToSend(inputToBlock.keyId, inputBlockData.fBlockDuration, inputBlockData.bAllDeviceIndices, inputBlockData.deviceIndex);
  1739.                                         m_pInput->SetBlockingInput(inputDataToSend);
  1740.                                 }
  1741.                         }
  1742.                         break;
  1743.                 case eAIBT_Clear:
  1744.                         {
  1745.                                 m_pInput->ClearBlockingInputs();
  1746.                         }
  1747.                         break;
  1748.                 }
  1749.         }
  1750. }
  1751.  
  1752. //------------------------------------------------------------------------
  1753. bool CActionMapManager::CreateRefiredEventPriorityList(SRefireData* pRefireData,
  1754.                                                        TBindPriorityList& priorityList,
  1755.                                                        TBindPriorityList& removeList,
  1756.                                                        TBindPriorityList& delayPressNeedsReleaseList)
  1757. {
  1758.         bool bRes = false;
  1759.  
  1760.         uint32 inputCRC = pRefireData->m_inputCRC;
  1761.         SInputEvent& inputEvent = pRefireData->m_inputEvent;
  1762.         TRefireBindData& refireBindData = pRefireData->m_refireBindData;
  1763.  
  1764.         // Look up the actions which are associated with this
  1765.         TRefireBindData::iterator it = refireBindData.begin();
  1766.         TRefireBindData::const_iterator itEnd = refireBindData.end();
  1767.  
  1768.         float fCurrTime = gEnv->pTimer->GetCurrTime();
  1769.         IGameFramework* pGameFramework = gEnv->pGameFramework;
  1770.         if (pGameFramework && pGameFramework->IsGamePaused())
  1771.         {
  1772.                 fCurrTime = gEnv->pTimer->GetCurrTime(ITimer::ETIMER_UI);
  1773.         }
  1774.  
  1775.         // Create priority listing for which processes should be fired
  1776.         float fLongestHeldTime = 0.0f;
  1777.         for (; it != itEnd; ++it)
  1778.         {
  1779.                 SRefireBindData& singleRefireBindData = *it;
  1780.                 SBindData& bindData = singleRefireBindData.m_bindData;
  1781.  
  1782.                 if (singleRefireBindData.m_bIgnoreNextUpdate) // Ignoring is set true when an actual input event has just added or updated a refiring event
  1783.                 {
  1784.                         singleRefireBindData.m_bIgnoreNextUpdate = false;
  1785.                         continue;
  1786.                 }
  1787.  
  1788.                 SActionInput* pActionInput = bindData.m_pActionInput;
  1789.                 CRY_ASSERT(pActionInput != NULL);
  1790.                 CActionMapAction* pAction = bindData.m_pAction;
  1791.                 CRY_ASSERT(pAction != NULL);
  1792.                 CActionMap* pActionMap = bindData.m_pActionMap;
  1793.                 CRY_ASSERT(pActionMap != NULL);
  1794.  
  1795.                 // Refire data could be either from analog repeating or delayed press
  1796.                 // If its a delayed press event, only fire once when reach delay then remove
  1797.                 if (inputEvent.state == eIS_Pressed)
  1798.                 {
  1799.                         const float fPressDelay = pActionInput->fPressTriggerDelay;
  1800.                         if (fPressDelay >= FLT_EPSILON) // Must be delayed press event
  1801.                         {
  1802.                                 if (fCurrTime - pActionInput->fPressedTime >= fPressDelay) // Meets delay so fire and mark for removal
  1803.                                 {
  1804.                                         removeList.push_back(&bindData);
  1805.  
  1806.                                         if (singleRefireBindData.m_bDelayedPressNeedsRelease) // Release must be fired after too
  1807.                                         {
  1808.                                                 delayPressNeedsReleaseList.push_back(&bindData);
  1809.                                         }
  1810.                                 }
  1811.                                 else // Don't fire yet
  1812.                                 {
  1813.                                         continue;
  1814.                                 }
  1815.                         }
  1816.                 }
  1817.  
  1818. #ifdef _DEBUG
  1819.  
  1820.                 CRY_ASSERT((pActionInput->inputCRC == inputCRC) && (strcmp(pActionInput->input.c_str(), inputEvent.keyName.c_str()) == 0)); \
  1821.  
  1822.                 if ((pActionInput->inputCRC == inputCRC) && (strcmp(pActionInput->input.c_str(), inputEvent.keyName.c_str()) != 0))
  1823.                 {
  1824.                         GameWarning("Hash values are identical, but values are different! %s - %s", pActionInput->input.c_str(), inputEvent.keyName.c_str());
  1825.                 }
  1826.                 if ((pActionInput->inputCRC != inputCRC) && (strcmp(pActionInput->input.c_str(), inputEvent.keyName.c_str()) == 0))
  1827.                 {
  1828.                         GameWarning("Hash values are different, but values are identical! %s - %s", pActionInput->input.c_str(), inputEvent.keyName.c_str());
  1829.                 }
  1830.  
  1831. #endif //_DEBUG
  1832.                 bool bAdd = (!ActionFiltered(pAction->GetActionId()) && pActionMap->CanProcessInput(inputEvent, pActionMap, pAction, pActionInput));
  1833.  
  1834.                 if (bAdd)
  1835.                 {
  1836.                         priorityList.push_back(&bindData);
  1837.                         bRes = true;
  1838.                 }
  1839.         }
  1840.  
  1841.         return bRes;
  1842. }
  1843.  
  1844. //------------------------------------------------------------------------
  1845. void CActionMapManager::UpdateRefiringInputs()
  1846. {
  1847.         FUNCTION_PROFILER(GetISystem(), PROFILE_ACTION);
  1848.  
  1849.         // no actions while console is open
  1850.         if (gEnv->pConsole->IsOpened())
  1851.                 return;
  1852.  
  1853.         if (gEnv->IsEditor() && gEnv->pGameFramework->IsEditing())
  1854.                 return;
  1855.  
  1856.         SetCurrentlyRefiringInput(true);
  1857.  
  1858.         TBindPriorityList removeList;
  1859.  
  1860.         std::vector<SRefireReleaseListData> releaseListRefireData;
  1861.  
  1862.         TInputCRCToRefireData::iterator iter = m_inputCRCToRefireData.begin();
  1863.         TInputCRCToRefireData::iterator iterEnd = m_inputCRCToRefireData.end();
  1864.         for (; iter != iterEnd; ++iter)
  1865.         {
  1866.                 SRefireData* pRefireData = iter->second;
  1867.                 const SInputEvent& event = pRefireData->m_inputEvent;
  1868.  
  1869.                 TBindPriorityList priorityList;
  1870.                 TBindPriorityList delayPressNeedsReleaseList;
  1871.  
  1872.                 bool bHasItems = CreateRefiredEventPriorityList(pRefireData, priorityList, removeList, delayPressNeedsReleaseList);
  1873.                 if (bHasItems)
  1874.                 {
  1875.                         HandleAcceptedEvents(event, priorityList);
  1876.  
  1877.                         if (m_bDelayedRemoveAllRefiringData) // Probably an action filter just got disabled which wants to remove all refire data, do it now
  1878.                         {
  1879.                                 m_bDelayedRemoveAllRefiringData = false;
  1880.                                 SetCurrentlyRefiringInput(false);
  1881.                                 RemoveAllRefireData();
  1882.                                 return;
  1883.                         }
  1884.                 }
  1885.  
  1886.                 if (delayPressNeedsReleaseList.empty() == false)
  1887.                 {
  1888.                         SRefireReleaseListData singleReleaseListRefireData;
  1889.                         singleReleaseListRefireData.m_inputEvent = event;
  1890.                         // Since not going through normal path for release event (Doesn't need to be checked, already approved for fire, just delayed)
  1891.                         // Need to manually change the current states to release before firing to ensure action is fired with a release
  1892.                         singleReleaseListRefireData.m_inputEvent.state = eIS_Released;
  1893.                         TBindPriorityList::iterator iterDelay = delayPressNeedsReleaseList.begin();
  1894.                         TBindPriorityList::const_iterator iterDelayEnd = delayPressNeedsReleaseList.end();
  1895.                         for (; iterDelay != iterDelayEnd; ++iterDelay)
  1896.                         {
  1897.                                 const SBindData* pReleaseBindData = *iterDelay;
  1898.                                 CRY_ASSERT(pReleaseBindData != NULL);
  1899.                                 SActionInput* pReleaseActionInput = pReleaseBindData->m_pActionInput;
  1900.                                 CRY_ASSERT(pReleaseActionInput != NULL);
  1901.                                 pReleaseActionInput->currentState = eIS_Released;
  1902.                         }
  1903.  
  1904.                         singleReleaseListRefireData.m_inputsList = delayPressNeedsReleaseList;
  1905.                         releaseListRefireData.push_back(singleReleaseListRefireData);
  1906.                 }
  1907.         }
  1908.  
  1909.         // Now process delayed release events which must happen after the delayed press
  1910.         const size_t eventCount = releaseListRefireData.size();
  1911.         for (size_t i = 0; i < eventCount; i++)
  1912.         {
  1913.                 SRefireReleaseListData& singleReleaseListRefireData = releaseListRefireData[i];
  1914.                 HandleAcceptedEvents(singleReleaseListRefireData.m_inputEvent, singleReleaseListRefireData.m_inputsList);
  1915.         }
  1916.         releaseListRefireData.clear();
  1917.         SetCurrentlyRefiringInput(false);
  1918.  
  1919.         // Safe to remove now
  1920.         TBindPriorityList::iterator removeIt = removeList.begin();
  1921.         TBindPriorityList::const_iterator removeItEnd = removeList.end();
  1922.         for (; removeIt != removeItEnd; ++removeIt)
  1923.         {
  1924.                 const SBindData* pBindData = *removeIt;
  1925.                 CRY_ASSERT(pBindData);
  1926.  
  1927.                 RemoveRefireData(pBindData->m_pActionMap, pBindData->m_pAction, pBindData->m_pActionInput);
  1928.         }
  1929.         removeList.clear();
  1930. }
  1931.  
downloadActionMapManager.cpp Source code - Download CRYENGINE Source code
Related Source Codes/Software:
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top