BVB Source Codes

CRYENGINE Show GameXmlParamReader.h Source code

Return Download CRYENGINE: download GameXmlParamReader.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. /*************************************************************************
  4.    -------------------------------------------------------------------------
  5.  
  6.    Description: Wrapper class for XmlNodeRef which allows to parse different contents
  7.    from xml depending on game mode SP or MP
  8.  
  9.    -------------------------------------------------------------------------
  10.    History:
  11.    - 23:09:2010   : Created by Benito Gangoso Rodriguez
  12.  
  13. *************************************************************************/
  14.  
  15. #pragma once
  16.  
  17. #ifndef _GAME_XML_PARAM_READER_H_
  18.         #define _GAME_XML_PARAM_READER_H_
  19.  
  20. class CGameXmlParamReader
  21. {
  22. public:
  23.  
  24.         explicit CGameXmlParamReader(const XmlNodeRef& xmlNode)
  25.                 : m_xmlNode(xmlNode)
  26.         {
  27.                 m_gameModeFilter = gEnv->bMultiplayer ? "MP" : "SP";
  28.         #if defined(_RELEASE)
  29.                 m_devmodeFilter = true;
  30.         #else
  31.                 m_devmodeFilter = false;
  32.         #endif //_RELEASE
  33.         }
  34.  
  35.         int GetUnfilteredChildCount() const
  36.         {
  37.                 if (m_xmlNode)
  38.                 {
  39.                         return m_xmlNode->getChildCount();
  40.                 }
  41.                 return 0;
  42.         }
  43.  
  44.         int GetFilteredChildCount() const
  45.         {
  46.                 int filteredChildCount = 0;
  47.                 if (m_xmlNode)
  48.                 {
  49.                         const int childCount = m_xmlNode->getChildCount();
  50.                         for (int i = 0; i < childCount; ++i)
  51.                         {
  52.                                 filteredChildCount += !IsNodeFiltered(m_xmlNode->getChild(i));
  53.                         }
  54.                 }
  55.                 return filteredChildCount;
  56.         }
  57.  
  58.         XmlNodeRef GetFilteredChildAt(int index) const
  59.         {
  60.                 if (m_xmlNode)
  61.                 {
  62.                         XmlNodeRef childNode = m_xmlNode->getChild(index);
  63.  
  64.                         return !IsNodeFiltered(childNode) ? childNode : XmlNodeRef((IXmlNode*)NULL);
  65.                 }
  66.  
  67.                 return NULL;
  68.         }
  69.  
  70.         XmlNodeRef FindFilteredChild(const char* childName) const
  71.         {
  72.                 if (m_xmlNode)
  73.                 {
  74.                         const int childCount = m_xmlNode->getChildCount();
  75.                         for (int i = 0; i < childCount; ++i)
  76.                         {
  77.                                 XmlNodeRef childNode = m_xmlNode->getChild(i);
  78.  
  79.                                 if (!IsNodeWithTag(childNode, childName) || IsNodeFiltered(childNode))
  80.                                 {
  81.                                         continue;
  82.                                 }
  83.  
  84.                                 return childNode;
  85.                         }
  86.                 }
  87.                 return NULL;
  88.         }
  89.  
  90.         const char* ReadParamValue(const char* paramName) const
  91.         {
  92.                 return ReadParamValue(paramName, "");
  93.         }
  94.  
  95.         const char* ReadParamValue(const char* paramName, const char* defaultValue) const
  96.         {
  97.                 if (m_xmlNode)
  98.                 {
  99.                         const int childCount = m_xmlNode->getChildCount();
  100.                         for (int i = 0; i < childCount; ++i)
  101.                         {
  102.                                 XmlNodeRef childNode = m_xmlNode->getChild(i);
  103.  
  104.                                 if (!HasNodeParamAttribute(childNode, paramName) || IsNodeFiltered(childNode))
  105.                                 {
  106.                                         continue;
  107.                                 }
  108.  
  109.                                 return childNode->getAttr("value");
  110.                         }
  111.                 }
  112.                 return defaultValue;
  113.         }
  114.  
  115.         const char* ReadParamAttributeValue(const char* paramName, const char* attributeName) const
  116.         {
  117.                 if (m_xmlNode)
  118.                 {
  119.                         const int childCount = m_xmlNode->getChildCount();
  120.                         for (int i = 0; i < childCount; ++i)
  121.                         {
  122.                                 XmlNodeRef childNode = m_xmlNode->getChild(i);
  123.  
  124.                                 if (!HasNodeParamAttribute(childNode, paramName) || IsNodeFiltered(childNode))
  125.                                 {
  126.                                         continue;
  127.                                 }
  128.  
  129.                                 return childNode->getAttr(attributeName);
  130.                         }
  131.                 }
  132.                 return "";
  133.         }
  134.  
  135.         template<typename T>
  136.         bool ReadParamValue(const char* paramName, T& value) const
  137.         {
  138.                 if (m_xmlNode)
  139.                 {
  140.                         const int childCount = m_xmlNode->getChildCount();
  141.                         for (int i = 0; i < childCount; ++i)
  142.                         {
  143.                                 XmlNodeRef childNode = m_xmlNode->getChild(i);
  144.  
  145.                                 if (!HasNodeParamAttribute(childNode, paramName) || IsNodeFiltered(childNode))
  146.                                 {
  147.                                         continue;
  148.                                 }
  149.  
  150.                                 return childNode->getAttr("value", value);
  151.                         }
  152.                 }
  153.                 return false;
  154.         }
  155.  
  156.         template<typename T>
  157.         bool ReadParamValue(const char* paramName, T& value, const T& defaultValue) const
  158.         {
  159.                 value = defaultValue;
  160.                 return ReadParamValue<T>(paramName, value);
  161.         }
  162.  
  163.         template<typename T>
  164.         bool ReadParamAttributeValue(const char* paramName, const char* attributeName, T& value) const
  165.         {
  166.                 if (m_xmlNode)
  167.                 {
  168.                         const int childCount = m_xmlNode->getChildCount();
  169.                         for (int i = 0; i < childCount; ++i)
  170.                         {
  171.                                 XmlNodeRef childNode = m_xmlNode->getChild(i);
  172.  
  173.                                 if (!HasNodeParamAttribute(childNode, paramName) || IsNodeFiltered(childNode))
  174.                                 {
  175.                                         continue;
  176.                                 }
  177.  
  178.                                 return childNode->getAttr(attributeName, value);
  179.                         }
  180.                 }
  181.                 return false;
  182.         }
  183.  
  184.         template<typename T>
  185.         bool ReadParamAttributeValue(const char* paramName, const char* attributeName, T& value, const T& defaultValue) const
  186.         {
  187.                 value = defaultValue;
  188.  
  189.                 return ReadParamAttributeValue<T>(paramName, attributeName, value);
  190.         }
  191.  
  192. private:
  193.  
  194.         bool IsNodeFiltered(const XmlNodeRef& xmlNode) const
  195.         {
  196.                 CRY_ASSERT(xmlNode != (IXmlNode*)NULL);
  197.  
  198.                 const char* gameAttribute = xmlNode->getAttr("GAME");
  199.  
  200.                 int devmodeFilter = 0;
  201.                 xmlNode->getAttr("DEVMODE", devmodeFilter);
  202.                 if (devmodeFilter != 0)
  203.                 {
  204.                         int i = 0;
  205.                 }
  206.  
  207.                 const bool devmodeFiltered = devmodeFilter != 0 && m_devmodeFilter;
  208.                 const bool gameModeFiltered = (gameAttribute != NULL) && gameAttribute[0] && (strcmp(gameAttribute, m_gameModeFilter.c_str()) != 0);
  209.  
  210.                 return devmodeFiltered || gameModeFiltered;
  211.         }
  212.  
  213.         bool IsNodeWithTag(const XmlNodeRef& xmlNode, const char* tag) const
  214.         {
  215.                 CRY_ASSERT(xmlNode != (IXmlNode*)NULL);
  216.  
  217.                 return (stricmp(xmlNode->getTag(), tag) == 0);
  218.         }
  219.  
  220.         bool HasNodeParamAttribute(const XmlNodeRef& xmlNode, const char* paramName) const
  221.         {
  222.                 CRY_ASSERT(xmlNode != (IXmlNode*)NULL);
  223.  
  224.                 const char* attributeName = xmlNode->getAttr("name");
  225.  
  226.                 return (attributeName != NULL && (stricmp(attributeName, paramName) == 0));
  227.         }
  228.  
  229.         const XmlNodeRef&  m_xmlNode;
  230.         CryFixedStringT<4> m_gameModeFilter;
  231.         bool               m_devmodeFilter;
  232. };
  233.  
  234. #endif //_GAME_XML_PARAM_READER_H_
  235.  
downloadGameXmlParamReader.h 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