BVB Source Codes

CRYENGINE Show PlayerProfile.cpp Source code

Return Download CRYENGINE: download PlayerProfile.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #include "StdAfx.h"
  4. #include "PlayerProfile.h"
  5. #include "PlayerProfileManager.h"
  6. #include "CryAction.h"
  7. #include <iterator>
  8.  
  9. #include "IActionMapManager.h"
  10. #include <CryCore/Platform/IPlatformOS.h>
  11.  
  12. const char* CPlayerProfile::ATTRIBUTES_TAG = "Attributes";
  13. const char* CPlayerProfile::ACTIONMAPS_TAG = "ActionMaps";
  14. const char* CPlayerProfile::VERSION_TAG = "Version";
  15.  
  16. // merge attributes with profile and default profile
  17. class CAttributeEnumerator : public IAttributeEnumerator
  18. {
  19.         struct AttributeComparer
  20.         {
  21.                 bool operator()(const CPlayerProfile::TAttributeMap::value_type& lhs, const CPlayerProfile::TAttributeMap::value_type& rhs) const
  22.                 {
  23.                         return lhs.first.compare(rhs.first) < 0;
  24.                 }
  25.         };
  26.  
  27. public:
  28.  
  29.         CAttributeEnumerator(CPlayerProfile* pProfile) :
  30.                 m_nRefs(0)
  31.         {
  32.                 const CPlayerProfile::TAttributeMap& localMap = pProfile->GetAttributeMap();
  33.                 const CPlayerProfile::TAttributeMap& parentMap = pProfile->GetDefaultAttributeMap();
  34.                 std::merge(localMap.begin(), localMap.end(), parentMap.begin(), parentMap.end(),
  35.                            std::inserter(m_mergedMap, m_mergedMap.begin()), AttributeComparer());
  36.  
  37.                 m_cur = m_mergedMap.begin();
  38.                 m_end = m_mergedMap.end();
  39.         }
  40.  
  41.         bool Next(SAttributeDescription& desc)
  42.         {
  43.                 if (m_cur != m_end)
  44.                 {
  45.                         desc.name = m_cur->first.c_str();
  46.                         ++m_cur;
  47.                         return true;
  48.                 }
  49.                 desc.name = "";
  50.                 return false;
  51.         }
  52.  
  53.         void AddRef()
  54.         {
  55.                 ++m_nRefs;
  56.         }
  57.  
  58.         void Release()
  59.         {
  60.                 if (0 == --m_nRefs)
  61.                         delete this;
  62.         }
  63.  
  64. private:
  65.         int m_nRefs;
  66.         CPlayerProfile::TAttributeMap::iterator m_cur;
  67.         CPlayerProfile::TAttributeMap::iterator m_end;
  68.         CPlayerProfile::TAttributeMap           m_mergedMap;
  69. };
  70.  
  71. //------------------------------------------------------------------------
  72. CPlayerProfile::CPlayerProfile(CPlayerProfileManager* pManager, const char* name, const char* userId, bool bIsPreview)
  73.         : m_pManager(pManager), m_name(name), m_userId(userId), m_bIsPreview(bIsPreview), m_attributesVersion(0)
  74. {
  75. }
  76.  
  77. //------------------------------------------------------------------------
  78. CPlayerProfile::~CPlayerProfile()
  79. {
  80. }
  81.  
  82. //------------------------------------------------------------------------
  83. bool CPlayerProfile::Reset()
  84. {
  85.         if (IsDefault())
  86.                 return false;
  87.  
  88.         // for now, try to get the action map from the IActionMapManager
  89.         IActionMapManager* pAM = CCryAction::GetCryAction()->GetIActionMapManager();
  90.         pAM->Reset();
  91.         // well, not very efficient at the moment...
  92.         TAttributeMap::iterator iter = m_attributeMap.begin();
  93.         while (iter != m_attributeMap.end())
  94.         {
  95.                 TAttributeMap::iterator next = iter;
  96.                 ++next;
  97.                 ResetAttribute(iter->first);
  98.                 iter = next;
  99.         }
  100.  
  101.         LoadGamerProfileDefaults();
  102.         gEnv->pSystem->AutoDetectSpec(false);
  103.  
  104.         return true;
  105. }
  106.  
  107. //------------------------------------------------------------------------
  108. // is this the default profile? it cannot be modified
  109. bool CPlayerProfile::IsDefault() const
  110. {
  111.         return m_pManager->GetDefaultProfile() == this;
  112. }
  113.  
  114. //------------------------------------------------------------------------
  115. // override values with console player profile defaults
  116. void CPlayerProfile::LoadGamerProfileDefaults()
  117. {
  118.         ICVar* pSysSpec = gEnv->pConsole->GetCVar("sys_spec");
  119.         if (pSysSpec && !(pSysSpec->GetFlags() & VF_WASINCONFIG))
  120.         {
  121.                 gEnv->pSystem->AutoDetectSpec(true);
  122.         }
  123.  
  124.         IPlatformOS::SUserProfileVariant preference;
  125.         IPlatformOS::TUserName userName = GetName();
  126.         unsigned int user;
  127.         if (gEnv->pSystem->GetPlatformOS()->UserIsSignedIn(userName, user) && user != IPlatformOS::Unknown_User)
  128.         {
  129.                 if (gEnv->pSystem->GetPlatformOS()->GetUserProfilePreference(user, IPlatformOS::EUPP_CONTROLLER_INVERT_Y, preference))
  130.                 {
  131.                         TFlowInputData value(preference.GetInt());
  132.                         SetAttribute("InvertY", value);
  133.                 }
  134.                 if (gEnv->pSystem->GetPlatformOS()->GetUserProfilePreference(user, IPlatformOS::EUPP_CONTROLLER_SENSITIVITY, preference))
  135.                 {
  136.                         TFlowInputData value(preference.GetFloat());
  137.                         SetAttribute("Sensitivity", value);
  138.                 }
  139.                 if (gEnv->pSystem->GetPlatformOS()->GetUserProfilePreference(user, IPlatformOS::EUPP_GAME_DIFFICULTY, preference))
  140.                 {
  141.                         TFlowInputData value(preference.GetInt());
  142.                         SetAttribute("SP/Difficulty", value);
  143.                 }
  144.                 if (gEnv->pSystem->GetPlatformOS()->GetUserProfilePreference(user, IPlatformOS::EUPP_AIM_ASSIST, preference))
  145.                 {
  146.                         TFlowInputData value(preference.GetInt());
  147.                         SetAttribute("AimAssistance", value);
  148.                 }
  149.         }
  150. }
  151.  
  152. //------------------------------------------------------------------------
  153. // name of the profile
  154. const char* CPlayerProfile::GetName()
  155. {
  156.         return m_name.c_str();
  157. }
  158.  
  159. //------------------------------------------------------------------------
  160. // Id of the profile user
  161. const char* CPlayerProfile::GetUserId()
  162. {
  163.         return m_userId.c_str();
  164. }
  165.  
  166. //------------------------------------------------------------------------
  167. // retrieve the action map
  168. IActionMap* CPlayerProfile::GetActionMap(const char* name)
  169. {
  170.         // for now, try to get the action map from the IActionMapManager
  171.         IActionMapManager* pAM = CCryAction::GetCryAction()->GetIActionMapManager();
  172.         return pAM->GetActionMap(name);
  173. }
  174.  
  175. //------------------------------------------------------------------------
  176. // set the value of an attribute
  177. bool CPlayerProfile::SetAttribute(const char* name, const TFlowInputData& value)
  178. {
  179.         if (IsDefault())
  180.                 return false;
  181.  
  182.         m_attributeMap[name] = value;
  183.         return true;
  184. }
  185.  
  186. //------------------------------------------------------------------------
  187. // re-set attribute to default value (basically removes it from this profile)
  188. bool CPlayerProfile::ResetAttribute(const char* name)
  189. {
  190.         if (IsDefault())
  191.                 return false;
  192.  
  193.         const TAttributeMap& defaultMap = GetDefaultAttributeMap();
  194.         // resetting means deleting from this profile and using the default value
  195.         // but: if no entry in default map, keep it
  196.         if (defaultMap.find(CONST_TEMP_STRING(name)) != defaultMap.end())
  197.         {
  198.                 TAttributeMap::size_type count = m_attributeMap.erase(name);
  199.                 return count > 0;
  200.         }
  201.         return false;
  202. }
  203. //------------------------------------------------------------------------
  204. // delete an attribute from attribute map (regardless if has a default)
  205. void CPlayerProfile::DeleteAttribute(const char* name)
  206. {
  207.         m_attributeMap.erase(name);
  208. }
  209.  
  210. //------------------------------------------------------------------------
  211. // get the value of an attribute. if not specified optionally lookup in default profile
  212. bool CPlayerProfile::GetAttribute(const char* name, TFlowInputData& val, bool bUseDefaultFallback) const
  213. {
  214.         TAttributeMap::const_iterator iter = m_attributeMap.find(CONST_TEMP_STRING(name));
  215.         if (iter != m_attributeMap.end())
  216.         {
  217.                 val = iter->second;
  218.                 return true;
  219.         }
  220.         if (bUseDefaultFallback && !IsDefault())
  221.         {
  222.                 const TAttributeMap& defaultMap = GetDefaultAttributeMap();
  223.                 TAttributeMap::const_iterator iter2 = defaultMap.find(CONST_TEMP_STRING(name));
  224.                 if (iter2 != defaultMap.end())
  225.                 {
  226.                         val = iter2->second;
  227.                         return true;
  228.                 }
  229.         }
  230.         return false;
  231. }
  232.  
  233. //------------------------------------------------------------------------
  234. // get name all attributes available
  235. // all in this profile and inherited from default profile
  236. IAttributeEnumeratorPtr CPlayerProfile::CreateAttributeEnumerator()
  237. {
  238.         return new CAttributeEnumerator(this);
  239. }
  240.  
  241. // create an enumerator for all save games
  242. ISaveGameEnumeratorPtr CPlayerProfile::CreateSaveGameEnumerator()
  243. {
  244.         return m_pManager->CreateSaveGameEnumerator(GetUserId(), this);
  245. }
  246.  
  247. //------------------------------------------------------------------------
  248. ISaveGame* CPlayerProfile::CreateSaveGame()
  249. {
  250.         return m_pManager->CreateSaveGame(GetUserId(), this);
  251. }
  252.  
  253. //------------------------------------------------------------------------
  254. bool CPlayerProfile::DeleteSaveGame(const char* name)
  255. {
  256.         return m_pManager->DeleteSaveGame(GetUserId(), this, name);
  257. }
  258.  
  259. //------------------------------------------------------------------------
  260. ILoadGame* CPlayerProfile::CreateLoadGame()
  261. {
  262.         return m_pManager->CreateLoadGame(GetUserId(), this);
  263. }
  264.  
  265. ILevelRotationFile* CPlayerProfile::GetLevelRotationFile(const char* name)
  266. {
  267.         return m_pManager->GetLevelRotationFile(GetUserId(), this, name);
  268. }
  269.  
  270. //------------------------------------------------------------------------
  271. void CPlayerProfile::SetName(const char* name)
  272. {
  273.         m_name = name;
  274. }
  275.  
  276. void CPlayerProfile::SetUserId(const char* userId)
  277. {
  278.         m_userId = userId;
  279. }
  280.  
  281. //------------------------------------------------------------------------
  282. bool CPlayerProfile::SerializeXML(CPlayerProfileManager::IProfileXMLSerializer* pSerializer)
  283. {
  284.         if (pSerializer->IsLoading())
  285.         {
  286.                 // serialize attributes
  287.                 XmlNodeRef attributesNode = pSerializer->GetSection(CPlayerProfileManager::ePPS_Attribute);
  288.                 if (attributesNode)
  289.                 {
  290.                         CPlayerProfile* pDefaultProfile = static_cast<CPlayerProfile*>(m_pManager->GetDefaultProfile());
  291.                         int requiredVersion = 0;
  292.                         if (IsDefault() == false && pDefaultProfile)
  293.                                 requiredVersion = pDefaultProfile->m_attributesVersion;
  294.                         bool ok = LoadAttributes(attributesNode, requiredVersion);
  295.                 }
  296.                 else
  297.                 {
  298.                         GameWarning("CPlayerProfile::SerializeXML: No attributes tag '%s' found", ATTRIBUTES_TAG);
  299.                         return false;
  300.                 }
  301.  
  302.                 // preview profiles never load actionmaps!
  303.                 if (m_bIsPreview == false)
  304.                 {
  305.                         // serialize action maps
  306.                         XmlNodeRef actionMaps = pSerializer->GetSection(CPlayerProfileManager::ePPS_Actionmap);
  307.                         if (actionMaps)
  308.                         {
  309.                                 // the default profile loaded has no associated actionmaps, but
  310.                                 // rather assumes that all actionmaps which are currently loaded belong to the default
  311.                                 // profile
  312.                                 // if it's not the default profile to be loaded, then we load the ActionMap
  313.                                 // but we do a version check. if the profile's actionmaps are outdated, it's not loaded
  314.                                 // but the default action map is used instead
  315.                                 // on saving the profile it's automatically updated (e.g. the current actionmaps [correct version]
  316.                                 // are saved
  317.                                 IActionMapManager* pAM = CCryAction::GetCryAction()->GetIActionMapManager();
  318.                                 if (IsDefault() == false && pAM)
  319.                                 {
  320.                                         pAM->Reset();
  321.  
  322.                                         pAM->LoadRebindDataFromXML(actionMaps); // check version and don't load if outdated
  323.                                 }
  324.                         }
  325.                         else
  326.                         {
  327.                                 GameWarning("CPlayerProfile::SerializeXML: No actionmaps tag '%s' found", ACTIONMAPS_TAG);
  328.                                 return false;
  329.                         }
  330.                 }
  331.         }
  332.         else
  333.         {
  334.                 if (m_bIsPreview == false)
  335.                 {
  336.                         // serialize attributes
  337.                         XmlNodeRef attributesNode = pSerializer->CreateNewSection(CPlayerProfileManager::ePPS_Attribute, CPlayerProfile::ATTRIBUTES_TAG);
  338.                         bool ok = SaveAttributes(attributesNode);
  339.                         if (!ok)
  340.                                 return false;
  341.  
  342.                         // serialize action maps
  343.                         IActionMapManager* pAM = CCryAction::GetCryAction()->GetIActionMapManager();
  344.                         XmlNodeRef actionMapsNode = pSerializer->CreateNewSection(CPlayerProfileManager::ePPS_Actionmap, CPlayerProfile::ACTIONMAPS_TAG);
  345.                         pAM->SaveRebindDataToXML(actionMapsNode);
  346.                         return ok;
  347.                 }
  348.         }
  349.         return true;
  350. }
  351.  
  352. //------------------------------------------------------------------------
  353. const CPlayerProfile::TAttributeMap& CPlayerProfile::GetDefaultAttributeMap() const
  354. {
  355.         CPlayerProfile* pDefaultProfile = static_cast<CPlayerProfile*>(m_pManager->GetDefaultProfile());
  356.         assert(pDefaultProfile != 0);
  357.         return pDefaultProfile->GetAttributeMap();
  358. }
  359.  
  360. //------------------------------------------------------------------------
  361. bool CPlayerProfile::SaveAttributes(const XmlNodeRef& root)
  362. {
  363.         if (m_attributesVersion > 0)
  364.                 root->setAttr(VERSION_TAG, m_attributesVersion);
  365.  
  366.         const TAttributeMap& defaultMap = GetDefaultAttributeMap();
  367.         TAttributeMap::iterator iter = m_attributeMap.begin();
  368.         while (iter != m_attributeMap.end())
  369.         {
  370.                 string val;
  371.                 iter->second.GetValueWithConversion(val);
  372.                 bool bSaveIt = true;
  373.                 TAttributeMap::const_iterator defaultIter = defaultMap.find(iter->first);
  374.                 if (defaultIter != defaultMap.end())
  375.                 {
  376.                         string defaultVal;
  377.                         defaultIter->second.GetValueWithConversion(defaultVal);
  378.                         // check if value is different from default
  379.                         bSaveIt = val != defaultVal;
  380.                 }
  381.                 if (m_pManager->IsOnlineOnlyAttribute(iter->first))
  382.                 {
  383.                         bSaveIt = false;
  384.                 }
  385.                 if (bSaveIt)
  386.                 {
  387.                         // TODO: config. variant saving
  388.                         XmlNodeRef child = root->newChild("Attr");
  389.                         child->setAttr("name", iter->first);
  390.                         child->setAttr("value", val);
  391.                 }
  392.                 ++iter;
  393.         }
  394.  
  395.         if (m_pManager->HasEnabledOnlineAttributes() && m_pManager->CanProcessOnlineAttributes() && !IsDefault())
  396.         {
  397.                 m_pManager->SaveOnlineAttributes(this);
  398.         }
  399.  
  400.         return true;
  401. }
  402.  
  403. //------------------------------------------------------------------------
  404. bool CPlayerProfile::LoadAttributes(const XmlNodeRef& root, int requiredVersion)
  405. {
  406.         int version = 0;
  407.         const bool bHaveVersion = root->getAttr(VERSION_TAG, version);
  408.  
  409.         if (requiredVersion > 0)
  410.         {
  411.                 if (bHaveVersion && version < requiredVersion)
  412.                 {
  413.                         GameWarning("CPlayerProfile::LoadAttributes: Attributes of profile '%s' have different version (%d != %d). Updated.", GetName(), version, requiredVersion);
  414.                         return false;
  415.                 }
  416.                 else if (!bHaveVersion)
  417.                 {
  418.                         GameWarning("CPlayerProfile::LoadAttributes: Attributes of legacy profile '%s' has no version (req=%d). Loading anyway.", GetName(), requiredVersion);
  419.                 }
  420.                 m_attributesVersion = requiredVersion;
  421.         }
  422.         else
  423.                 // for default profile we set the version we found in the rootNode
  424.                 m_attributesVersion = version;
  425.  
  426.         int nChilds = root->getChildCount();
  427.         for (int i = 0; i < nChilds; ++i)
  428.         {
  429.                 XmlNodeRef child = root->getChild(i);
  430.                 if (child && strcmp(child->getTag(), "Attr") == 0)
  431.                 {
  432.                         const char* name = child->getAttr("name");
  433.                         const char* value = child->getAttr("value");
  434.                         const char* platform = child->getAttr("platform");
  435.  
  436.                         bool platformValid = true;
  437.                         if (platform != NULL && platform[0])
  438.                         {
  439. #if CRY_PLATFORM_DURANGO
  440.                                 platformValid = (strstr(platform, "xbox") != 0);
  441. #elif CRY_PLATFORM_ORBIS
  442.                                 platformValid = (strstr(platform, "ps4") != 0);
  443. #else
  444.                                 platformValid = (strstr(platform, "pc") != 0);
  445. #endif
  446.                         }
  447.  
  448.                         if (name && value && platformValid)
  449.                         {
  450.                                 m_attributeMap[name] = TFlowInputData(string(value));
  451.                         }
  452.                 }
  453.         }
  454.  
  455.         if (m_pManager->HasEnabledOnlineAttributes() && m_pManager->CanProcessOnlineAttributes() && !IsDefault())
  456.         {
  457.                 m_pManager->LoadOnlineAttributes(this);
  458.         }
  459.  
  460.         return true;
  461. }
  462.  
  463. void CPlayerProfile::GetMemoryStatistics(ICrySizer* pSizer)
  464. {
  465.         pSizer->AddObject(this, sizeof(*this));
  466.         pSizer->AddObject(m_name);
  467.         pSizer->AddObject(m_userId);
  468.         pSizer->AddObject(m_attributeMap);
  469. }
  470.  
downloadPlayerProfile.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