BVB Source Codes

CRYENGINE Show GameTokenSystem.cpp Source code

Return Download CRYENGINE: download GameTokenSystem.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. // -------------------------------------------------------------------------
  4. //  File name:   CGameTokenSystem.cpp
  5. //  Version:     v1.00
  6. //  Created:     20/10/2005 by Craig,Timur.
  7. //  Compilers:   Visual Studio.NET
  8. //  Description:
  9. // -------------------------------------------------------------------------
  10. //  History:
  11. //
  12. ////////////////////////////////////////////////////////////////////////////
  13.  
  14. #include "StdAfx.h"
  15.  
  16. #include <CryAction.h>
  17. #include "GameTokenSystem.h"
  18. #include "GameToken.h"
  19. #include "ScriptBind_GameToken.h"
  20. #include "ILevelSystem.h"
  21. #include <CryRenderer/IRenderer.h>
  22.  
  23. #define SCRIPT_GAMETOKEN_ALWAYS_CREATE // GameToken.SetValue from Script always creates the token
  24. // #undef SCRIPT_GAMETOKEN_ALWAYS_CREATE     // GameToken.SetValue from Script warns if Token not found
  25.  
  26. #define DEBUG_GAME_TOKENS
  27. #undef DEBUG_GAME_TOKENS
  28.  
  29. class CGameTokenIterator : public IGameTokenIt
  30. {
  31. public:
  32.         CGameTokenIterator(CGameTokenSystem* pGTS) : m_pGTS(pGTS)
  33.         {
  34.                 CRY_ASSERT(pGTS);
  35.                 m_nRefCount = 0;
  36.                 MoveFirst();
  37.         }
  38.  
  39.         virtual ~CGameTokenIterator() {};
  40.  
  41.         bool IsEnd()
  42.         {
  43.                 if (!m_pGTS || !m_pGTS->m_pGameTokensMap)
  44.                         return true;
  45.  
  46.                 return (m_it == m_pGTS->m_pGameTokensMap->end());
  47.         }
  48.  
  49.         IGameToken* This()
  50.         {
  51.                 if (IsEnd())
  52.                         return 0;
  53.                 else
  54.                         return m_it->second;
  55.         }
  56.  
  57.         IGameToken* Next()
  58.         {
  59.                 if (IsEnd())
  60.                         return 0;
  61.                 else
  62.                 {
  63.                         IGameToken* pCurrent = m_it->second;
  64.                         std::advance(m_it, 1);
  65.                         return pCurrent;
  66.                 }
  67.         }
  68.  
  69.         void MoveFirst()
  70.         {
  71.                 if (m_pGTS && m_pGTS->m_pGameTokensMap)
  72.                         m_it = m_pGTS->m_pGameTokensMap->begin();
  73.         };
  74.  
  75.         void AddRef()  { m_nRefCount++; }
  76.  
  77.         void Release() { --m_nRefCount; if (m_nRefCount <= 0) { delete this; } }
  78.  
  79. protected: // ---------------------------------------------------
  80.         CGameTokenSystem*                         m_pGTS;
  81.         int                                       m_nRefCount; //
  82.  
  83.         CGameTokenSystem::GameTokensMap::iterator m_it;
  84. };
  85.  
  86. #ifdef _GAMETOKENSDEBUGINFO
  87. int CGameTokenSystem::m_CVarShowDebugInfo = 0;
  88. int CGameTokenSystem::m_CVarPosX = 0;
  89. int CGameTokenSystem::m_CVarPosY = 0;
  90. int CGameTokenSystem::m_CVarNumHistoricLines = DBG_HISTORYSIZE;
  91. ICVar* CGameTokenSystem::m_pCVarFilter = NULL;
  92. #endif
  93.  
  94. //////////////////////////////////////////////////////////////////////////
  95. #ifdef _GAMETOKENSDEBUGINFO
  96. namespace
  97. {
  98. void AddGameTokenToDebugList(IConsoleCmdArgs* pArgs)
  99. {
  100.         IGameTokenSystem* pGameTokenSystem = CCryAction::GetCryAction()->GetIGameTokenSystem();
  101.         if (pGameTokenSystem && pArgs->GetArgCount() > 1)
  102.                 pGameTokenSystem->AddTokenToDebugList(pArgs->GetArg(1));
  103. }
  104.  
  105. void RemoveGameTokenFromDebugList(IConsoleCmdArgs* pArgs)
  106. {
  107.         IGameTokenSystem* pGameTokenSystem = CCryAction::GetCryAction()->GetIGameTokenSystem();
  108.         if (pGameTokenSystem && pArgs->GetArgCount() > 1)
  109.                 pGameTokenSystem->RemoveTokenFromDebugList(pArgs->GetArg(1));
  110. }
  111. }
  112. #endif
  113.  
  114. //////////////////////////////////////////////////////////////////////////
  115. CGameTokenSystem::CGameTokenSystem()
  116. {
  117.         CGameToken::g_pGameTokenSystem = this;
  118.         m_pScriptBind = new CScriptBind_GameToken(this);
  119.         m_pGameTokensMap = new GameTokensMap();
  120.  
  121. #ifdef _GAMETOKENSDEBUGINFO
  122.         m_debugHistory.resize(DBG_HISTORYSIZE);
  123.         ClearDebugHistory();
  124.         REGISTER_CVAR2("gt_show", &CGameTokenSystem::m_CVarShowDebugInfo, 0, 0, "Show Game Tokens debug info. 1=screen and log, 2=screen only, 3=log only");
  125.         REGISTER_CVAR2("gt_showPosX", &CGameTokenSystem::m_CVarPosX, 0, 0, "Defines the starting column in screen for game tokens debug info");
  126.         REGISTER_CVAR2("gt_showPosY", &CGameTokenSystem::m_CVarPosY, 0, 0, "Defines the starting line in screen for game tokens debug info");
  127.         REGISTER_CVAR2("gt_showLines", &CGameTokenSystem::m_CVarNumHistoricLines, DBG_HISTORYSIZE, 0, "How many lines is used by the historic list");
  128.         m_pCVarFilter = REGISTER_STRING("gt_showFilter", NULL, VF_NULL, "In the historic list only shows game tokens that include the filter string");
  129.         REGISTER_COMMAND("gt_AddToDebugList", AddGameTokenToDebugList, VF_CHEAT, "Adds a game token by name to the list of game tokens to be shown on screen");
  130.         REGISTER_COMMAND("gt_RemoveFromDebugList", RemoveGameTokenFromDebugList, VF_CHEAT, "Removes a game token by name from the list of game tokens to be shown on screen");
  131. #endif
  132. }
  133.  
  134. //////////////////////////////////////////////////////////////////////////
  135. CGameTokenSystem::~CGameTokenSystem()
  136. {
  137.         if (m_pScriptBind)
  138.                 delete m_pScriptBind;
  139.  
  140.         IConsole* pConsole = gEnv->pConsole;
  141.         pConsole->UnregisterVariable("gt_show", true);
  142.         pConsole->UnregisterVariable("gt_showPosX", true);
  143.         pConsole->UnregisterVariable("gt_showPosY", true);
  144.         pConsole->UnregisterVariable("gt_showLines", true);
  145.         pConsole->UnregisterVariable("gt_showFilter", true);
  146. }
  147.  
  148. //////////////////////////////////////////////////////////////////////////
  149. IGameToken* CGameTokenSystem::SetOrCreateToken(const char* sTokenName, const TFlowInputData& defaultValue)
  150. {
  151.         CRY_ASSERT(sTokenName);
  152.         if (*sTokenName == 0) // empty string
  153.         {
  154.                 GameWarning(_HELP("Creating game token with empty name"));
  155.                 return 0;
  156.         }
  157.  
  158. #ifdef DEBUG_GAME_TOKENS
  159.         GameTokensMap::iterator iter(m_pGameTokensMap->begin());
  160.         CryLogAlways("GT 0x%p: DEBUG looking for token '%s'", this, sTokenName);
  161.         while (iter != m_pGameTokensMap->end())
  162.         {
  163.                 CryLogAlways("GT 0x%p: Token key='%s' name='%s' Val='%s'", this, (*iter).first, (*iter).second->GetName(), (*iter).second->GetValueAsString());
  164.                 ++iter;
  165.         }
  166. #endif
  167.  
  168.         // Check if token already exist, if it is return existing token.
  169.         CGameToken* pToken = stl::find_in_map(*m_pGameTokensMap, sTokenName, NULL);
  170.         if (pToken)
  171.         {
  172.                 pToken->SetValue(defaultValue);
  173.                 // Should we also output a warning here?
  174.                 // GameWarning( "Game Token 0x%p %s already exist. New value %s", pToken, sTokenName, pToken->GetValueAsString());
  175.                 return pToken;
  176.         }
  177.         pToken = new CGameToken;
  178.         pToken->m_name = sTokenName;
  179.         pToken->m_value = defaultValue;
  180.         (*m_pGameTokensMap)[pToken->m_name.c_str()] = pToken;
  181.  
  182.         return pToken;
  183. }
  184.  
  185. //////////////////////////////////////////////////////////////////////////
  186. void CGameTokenSystem::DeleteToken(IGameToken* pToken)
  187. {
  188.         CRY_ASSERT(pToken);
  189.         GameTokensMap::iterator it = m_pGameTokensMap->find(((CGameToken*)pToken)->m_name.c_str());
  190.         if (it != m_pGameTokensMap->end())
  191.         {
  192. #ifdef DEBUG_GAME_TOKENS
  193.                 CryLogAlways("GameTokenSystemNew::DeleteToken: About to delete Token 0x%p '%s' val=%s", pToken, pToken->GetName(), pToken->GetValueAsString());
  194. #endif
  195.  
  196.                 m_pGameTokensMap->erase(it);
  197.                 delete (CGameToken*)pToken;
  198.         }
  199. }
  200.  
  201. //////////////////////////////////////////////////////////////////////////
  202. IGameToken* CGameTokenSystem::FindToken(const char* sTokenName)
  203. {
  204.         if (m_pGameTokensMap)
  205.                 return stl::find_in_map(*m_pGameTokensMap, sTokenName, NULL);
  206.         else
  207.                 return NULL;
  208. }
  209.  
  210. //////////////////////////////////////////////////////////////////////////
  211. void CGameTokenSystem::RenameToken(IGameToken* pToken, const char* sNewName)
  212. {
  213.         CRY_ASSERT(pToken);
  214.         CGameToken* pCToken = (CGameToken*)pToken;
  215.         GameTokensMap::iterator it = m_pGameTokensMap->find(pCToken->m_name.c_str());
  216.         if (it != m_pGameTokensMap->end())
  217.                 m_pGameTokensMap->erase(it);
  218. #ifdef DEBUG_GAME_TOKENS
  219.         CryLogAlways("GameTokenSystemNew::RenameToken: 0x%p '%s' -> '%s'", pCToken, pCToken->m_name, sNewName);
  220. #endif
  221.         pCToken->m_name = sNewName;
  222.         (*m_pGameTokensMap)[pCToken->m_name.c_str()] = pCToken;
  223. }
  224.  
  225. IGameTokenIt* CGameTokenSystem::GetGameTokenIterator()
  226. {
  227.         return new CGameTokenIterator(this);
  228. }
  229.  
  230. //////////////////////////////////////////////////////////////////////////
  231. CGameToken* CGameTokenSystem::GetToken(const char* sTokenName)
  232. {
  233.         // Load library if not found.
  234.         CGameToken* pToken = stl::find_in_map(*m_pGameTokensMap, sTokenName, NULL);
  235.         if (!pToken)
  236.         {
  237.                 //@TODO: Load game token lib here.
  238.         }
  239.         return pToken;
  240. }
  241.  
  242. //////////////////////////////////////////////////////////////////////////
  243. void CGameTokenSystem::RegisterListener(const char* sGameToken, IGameTokenEventListener* pListener, bool bForceCreate, bool bImmediateCallback)
  244. {
  245.         CGameToken* pToken = GetToken(sGameToken);
  246.  
  247.         if (!pToken && bForceCreate)
  248.         {
  249.                 pToken = new CGameToken;
  250.                 pToken->m_name = sGameToken;
  251.                 pToken->m_value = TFlowInputData(0.0f);
  252.                 (*m_pGameTokensMap)[pToken->m_name.c_str()] = pToken;
  253.         }
  254.  
  255.         if (pToken)
  256.         {
  257.                 pToken->AddListener(pListener);
  258.  
  259.                 if (bImmediateCallback)
  260.                 {
  261.                         pListener->OnGameTokenEvent(EGAMETOKEN_EVENT_CHANGE, pToken);
  262.                 }
  263.         }
  264. }
  265.  
  266. //////////////////////////////////////////////////////////////////////////
  267. void CGameTokenSystem::UnregisterListener(const char* sGameToken, IGameTokenEventListener* pListener)
  268. {
  269.         CGameToken* pToken = GetToken(sGameToken);
  270.         if (pToken)
  271.         {
  272.                 pToken->RemoveListener(pListener);
  273.         }
  274. }
  275.  
  276. //////////////////////////////////////////////////////////////////////////
  277. void CGameTokenSystem::RegisterListener(IGameTokenEventListener* pListener)
  278. {
  279.         stl::push_back_unique(m_listeners, pListener);
  280. }
  281.  
  282. //////////////////////////////////////////////////////////////////////////
  283. void CGameTokenSystem::UnregisterListener(IGameTokenEventListener* pListener)
  284. {
  285.         stl::find_and_erase(m_listeners, pListener);
  286. }
  287.  
  288. //////////////////////////////////////////////////////////////////////////
  289. void CGameTokenSystem::Notify(EGameTokenEvent event, CGameToken* pToken)
  290. {
  291.         for (Listeners::iterator it = m_listeners.begin(); it != m_listeners.end(); ++it)
  292.         {
  293.                 (*it)->OnGameTokenEvent(event, pToken);
  294.         }
  295.         if (pToken)
  296.                 pToken->Notify(event);
  297.  
  298. #ifdef _GAMETOKENSDEBUGINFO
  299.         if (CGameTokenSystem::m_CVarShowDebugInfo != 0 && pToken)
  300.         {
  301.                 bool filterPass = true;
  302.                 if (m_pCVarFilter && m_pCVarFilter->GetString() != NULL && m_pCVarFilter->GetString()[0] != 0)
  303.                 {
  304.                         stack_string temp1 = m_pCVarFilter->GetString();
  305.                         temp1.MakeUpper();
  306.                         stack_string temp2 = pToken->GetName();
  307.                         temp2.MakeUpper();
  308.                         filterPass = strstr(temp2.c_str(), temp1.c_str()) != NULL;
  309.                 }
  310.  
  311.                 if (filterPass)
  312.                 {
  313.                         int numHistoryLines = GetHistoryBufferSize();
  314.                         if (numHistoryLines != m_oldNumHistoryLines)
  315.                                 ClearDebugHistory();
  316.  
  317.                         if (numHistoryLines > 0)
  318.                         {
  319.                                 if (m_historyEnd >= numHistoryLines)
  320.                                         m_historyEnd = 0;
  321.                                 else
  322.                                 {
  323.                                         m_historyEnd = (m_historyEnd + 1) % numHistoryLines;
  324.                                         if (m_historyEnd == m_historyStart)
  325.                                                 m_historyStart = (m_historyStart + 1) % numHistoryLines;
  326.                                 }
  327.  
  328.                                 SDebugHistoryEntry& entry = m_debugHistory[m_historyEnd];
  329.                                 entry.tokenName = pToken->GetName();
  330.                                 entry.value = GetTokenDebugString(pToken);
  331.                                 entry.timeChanged = pToken->GetLastChangeTime();
  332.                         }
  333.                         if (CGameTokenSystem::m_CVarShowDebugInfo != 2)
  334.                                 CryLog("---GAMETOKEN CHANGE.  '%s' = '%s'", pToken->GetName(), pToken->GetValueAsString());
  335.                 }
  336.         }
  337. #endif
  338. }
  339.  
  340. //////////////////////////////////////////////////////////////////////////
  341. void CGameTokenSystem::Serialize(TSerialize ser)
  342. {
  343.         // when writing game tokens we store the per-level tokens (Level.xxx) in a group
  344.         // with the real level name
  345.  
  346.         TFlowInputData data;
  347.         std::vector<CGameToken*> levelTokens;
  348.         static const char* levelPrefix = "Level.";
  349.         static const size_t prefixLength = 6;
  350.         assert(strlen(levelPrefix) == prefixLength);
  351.         const bool bSaving = ser.IsWriting();
  352.  
  353.         if (bSaving)
  354.         {
  355.                 // Saving.
  356.                 if (m_levelToLevelSave)
  357.                 {
  358.                         IXmlStringData* xmlData = m_levelToLevelSave->getXMLData(5000);
  359.                         string strXMLData(xmlData->GetString());
  360.                         ser.Value("LTLGameTokensData", strXMLData);
  361.                         xmlData->Release();
  362.                 }
  363.  
  364.                 int nTokens = 0;
  365.                 ser.BeginGroup("GlobalTokens");
  366.                 if (!m_pGameTokensMap->empty())
  367.                 {
  368.                         GameTokensMap::iterator iter = m_pGameTokensMap->begin();
  369.                         GameTokensMap::iterator iterEnd = m_pGameTokensMap->end();
  370.                         while (iter != iterEnd)
  371.                         {
  372.                                 CGameToken* pToken = iter->second;
  373.  
  374.                                 if (0 == strncmp(levelPrefix, pToken->m_name.c_str(), prefixLength))
  375.                                 {
  376.                                         levelTokens.push_back(pToken);
  377.                                 }
  378.                                 else
  379.                                 {
  380.                                         nTokens++;
  381.                                         ser.BeginGroup("Token");
  382.                                         ser.Value("name", pToken->m_name);
  383.                                         ser.Value("flags", pToken->m_nFlags);
  384.                                         pToken->m_value.Serialize(ser);
  385.                                         ser.EndGroup();
  386.                                 }
  387.                                 ++iter;
  388.                         }
  389.                 }
  390.                 ser.Value("count", nTokens);
  391.                 ser.EndGroup();
  392.  
  393.                 nTokens = (int)levelTokens.size();
  394.                 ser.BeginGroup("LevelTokens");
  395.                 ser.Value("count", nTokens);
  396.                 if (!levelTokens.empty())
  397.                 {
  398.                         std::vector<CGameToken*>::iterator iter = levelTokens.begin();
  399.                         std::vector<CGameToken*>::iterator iterEnd = levelTokens.end();
  400.                         while (iter != iterEnd)
  401.                         {
  402.                                 CGameToken* pToken = *iter;
  403.                                 {
  404.                                         ser.BeginGroup("Token");
  405.                                         ser.Value("name", pToken->m_name);
  406.                                         ser.Value("flags", pToken->m_nFlags);
  407.                                         pToken->m_value.Serialize(ser);
  408.                                         ser.EndGroup();
  409.                                 }
  410.                                 ++iter;
  411.                         }
  412.                 }
  413.                 ser.EndGroup();
  414.         }
  415.         else
  416.         {
  417. #ifdef _GAMETOKENSDEBUGINFO
  418.                 ClearDebugHistory();
  419. #endif
  420.  
  421.                 // Loading.
  422.  
  423.                 {
  424.                         string strXMLData;
  425.                         ser.Value("LTLGameTokensData", strXMLData);
  426.                         m_levelToLevelSave = gEnv->pSystem->LoadXmlFromBuffer(strXMLData.c_str(), strXMLData.length());
  427.                 }
  428.  
  429.                 for (int pass = 0; pass < 2; pass++)
  430.                 {
  431.                         if (pass == 0)
  432.                                 ser.BeginGroup("GlobalTokens");
  433.                         else
  434.                                 ser.BeginGroup("LevelTokens");
  435.  
  436.                         string tokenName;
  437.                         int nTokens = 0;
  438.                         ser.Value("count", nTokens);
  439.                         uint32 flags = 0;
  440.                         for (int i = 0; i < nTokens; i++)
  441.                         {
  442.                                 ser.BeginGroup("Token");
  443.                                 ser.Value("name", tokenName);
  444.                                 ser.Value("flags", flags);
  445.                                 data.Serialize(ser);
  446.                                 CGameToken* pToken = (CGameToken*)FindToken(tokenName);
  447.                                 if (pToken)
  448.                                 {
  449.                                         pToken->m_value = data;
  450.                                         pToken->m_nFlags = flags;
  451.                                 }
  452.                                 else
  453.                                 {
  454.                                         // Create token.
  455.                                         pToken = (CGameToken*)SetOrCreateToken(tokenName, data);
  456.                                         pToken->m_nFlags = flags;
  457.                                 }
  458.                                 ser.EndGroup();
  459.                         }
  460.                         ser.EndGroup();
  461.                 }
  462.         }
  463. }
  464.  
  465. //////////////////////////////////////////////////////////////////////////
  466. void CGameTokenSystem::LoadLibs(const char* sFileSpec)
  467. {
  468.         LOADING_TIME_PROFILE_SECTION(GetISystem());
  469.  
  470.         ICryPak* pPak = gEnv->pCryPak;
  471.         _finddata_t fd;
  472.         string dir = PathUtil::GetPathWithoutFilename(sFileSpec);
  473.         intptr_t handle = pPak->FindFirst(sFileSpec, &fd);
  474.         if (handle != -1)
  475.         {
  476.                 int res = 0;
  477.                 do
  478.                 {
  479.                         _InternalLoadLibrary(PathUtil::Make(dir, fd.name), "GameTokensLibrary");
  480.                         res = pPak->FindNext(handle, &fd);
  481.                 }
  482.                 while (res >= 0);
  483.                 pPak->FindClose(handle);
  484.         }
  485. }
  486.  
  487. #if 0 // temp leave in
  488. bool CGameTokenSystem::LoadLevelLibrary(const char* sFileSpec, bool bEraseLevelTokens)
  489. {
  490.         if (bEraseLevelTokens)
  491.                 RemoveLevelTokens();
  492.  
  493.         return _InternalLoadLibrary(sFileSpec, "GameTokensLevelLibrary");
  494. }
  495. #endif
  496.  
  497. void CGameTokenSystem::RemoveLibrary(const char* sPrefix)
  498. {
  499.         if (m_pGameTokensMap)
  500.         {
  501.                 string prefixDot(sPrefix);
  502.                 prefixDot += ".";
  503.  
  504.                 GameTokensMap::iterator iter = m_pGameTokensMap->begin();
  505.                 while (iter != m_pGameTokensMap->end())
  506.                 {
  507.                         bool isLibToken(iter->second->m_name.find(prefixDot) == 0);
  508.                         GameTokensMap::iterator next = iter;
  509.                         ++next;
  510.                         if (isLibToken)
  511.                         {
  512.                                 CGameToken* pToDelete = (*iter).second;
  513.                                 m_pGameTokensMap->erase(iter);
  514.                                 SAFE_DELETE(pToDelete);
  515.                         }
  516.                         iter = next;
  517.                 }
  518.                 stl::find_and_erase(m_libraries, sPrefix);
  519.         }
  520. }
  521.  
  522. //////////////////////////////////////////////////////////////////////////
  523. void CGameTokenSystem::Unload()
  524. {
  525.         if (m_pGameTokensMap)
  526.         {
  527.                 GameTokensMap::iterator iter = m_pGameTokensMap->begin();
  528.                 while (iter != m_pGameTokensMap->end())
  529.                 {
  530.                         SAFE_DELETE((*iter).second);
  531.                         ++iter;
  532.                 }
  533.         }
  534.         if (!gEnv->IsEditor())
  535.         {
  536.                 SAFE_DELETE(m_pGameTokensMap);
  537.         }
  538.         stl::free_container(m_listeners);
  539.         stl::free_container(m_libraries);
  540. #ifdef _GAMETOKENSDEBUGINFO
  541.         ClearDebugHistory();
  542. #endif
  543. }
  544. //////////////////////////////////////////////////////////////////////////
  545. void CGameTokenSystem::Reset()
  546. {
  547.         if (m_pGameTokensMap)
  548.         {
  549.                 Unload();
  550.         }
  551.  
  552.         if (!m_pGameTokensMap)
  553.         {
  554.                 m_pGameTokensMap = new GameTokensMap();
  555.         }
  556. }
  557.  
  558. //////////////////////////////////////////////////////////////////////////
  559. bool CGameTokenSystem::_InternalLoadLibrary(const char* filename, const char* tag)
  560. {
  561.         XmlNodeRef root = GetISystem()->LoadXmlFromFile(filename);
  562.         if (!root)
  563.         {
  564.                 GameWarning(_HELP("Unable to load game token database: %s"), filename);
  565.                 return false;
  566.         }
  567.  
  568.         if (0 != strcmp(tag, root->getTag()))
  569.         {
  570.                 GameWarning(_HELP("Not a game tokens library : %s"), filename);
  571.                 return false;
  572.         }
  573.  
  574.         // GameTokens are (currently) not saved with their full path
  575.         // we expand it here to LibName.TokenName
  576.         string libName;
  577.         {
  578.                 const char* sLibName = root->getAttr("Name");
  579.                 if (sLibName == 0)
  580.                 {
  581.                         GameWarning("GameTokensLibrary::LoadLibrary: Unable to find LibName in file '%s'", filename);
  582.                         return false;
  583.                 }
  584.                 libName = sLibName;
  585.         }
  586.  
  587.         // we dont skip already loaded libraries anymore. We need to reload them to be sure that all necessary gametokens are present even if some level has not up-to-date libraries.
  588.         if (!stl::find(m_libraries, libName)) //return true;
  589.                 m_libraries.push_back(libName);
  590.  
  591.         libName += ".";
  592.  
  593.         int numChildren = root->getChildCount();
  594.         for (int i = 0; i < numChildren; i++)
  595.         {
  596.                 XmlNodeRef node = root->getChild(i);
  597.  
  598.                 const char* sName = node->getAttr("Name");
  599.                 const char* sType = node->getAttr("Type");
  600.                 const char* sValue = node->getAttr("Value");
  601.                 const char* sLocalOnly = node->getAttr("LocalOnly");
  602.                 int localOnly = atoi(sLocalOnly);
  603.  
  604.                 EFlowDataTypes tokenType = eFDT_Any;
  605.                 if (0 == strcmp(sType, "Int"))
  606.                         tokenType = eFDT_Int;
  607.                 else if (0 == strcmp(sType, "Float"))
  608.                         tokenType = eFDT_Float;
  609.                 else if (0 == strcmp(sType, "EntityId"))
  610.                         tokenType = eFDT_EntityId;
  611.                 else if (0 == strcmp(sType, "Vec3"))
  612.                         tokenType = eFDT_Vec3;
  613.                 else if (0 == strcmp(sType, "String"))
  614.                         tokenType = eFDT_String;
  615.                 else if (0 == strcmp(sType, "Bool"))
  616.                         tokenType = eFDT_Bool;
  617.  
  618.                 if (tokenType == eFDT_Any)
  619.                 {
  620.                         GameWarning(_HELP("Unknown game token type %s in token %s (%s:%d)"), sType, sName, node->getTag(), node->getLine());
  621.                         continue;
  622.                 }
  623.  
  624.                 TFlowInputData initialValue = TFlowInputData(string(sValue));
  625.  
  626.                 string fullName(libName);
  627.                 fullName += sName;
  628.  
  629.                 IGameToken* pToken = stl::find_in_map(*m_pGameTokensMap, fullName, NULL);
  630.                 if (!pToken)
  631.                 {
  632.                         pToken = SetOrCreateToken(fullName, initialValue);
  633.                         if (pToken && localOnly)
  634.                                 pToken->SetFlags(pToken->GetFlags() | EGAME_TOKEN_LOCALONLY);
  635.                 }
  636.         }
  637.         return true;
  638. }
  639.  
  640. //////////////////////////////////////////////////////////////////////////
  641. void CGameTokenSystem::SerializeSaveLevelToLevel(const char** ppGameTokensList, uint32 numTokensToSave)
  642. {
  643.         m_levelToLevelSave = gEnv->pSystem->CreateXmlNode("GameTokensLevelToLevel");
  644.  
  645.         IXmlSerializer* pSerializer = gEnv->pSystem->GetXmlUtils()->CreateXmlSerializer();
  646.         ISerialize* pSer = pSerializer->GetWriter(m_levelToLevelSave);
  647.         TSerialize ser = TSerialize(pSer);
  648.  
  649.         uint32 numTokensSaved = 0;
  650.         for (uint32 i = 0; i < numTokensToSave; ++i)
  651.         {
  652.                 const char* pName = ppGameTokensList[i];
  653.                 CGameToken* pToken = GetToken(pName);
  654.                 if (pToken)
  655.                 {
  656.                         numTokensSaved++;
  657.                         ser.BeginGroup("Token");
  658.                         ser.Value("name", pToken->m_name);
  659.                         pToken->m_value.Serialize(ser);
  660.                         ser.EndGroup();
  661.                 }
  662.                 else
  663.                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_ERROR, "GameTokenSystem. GameToken %s was not found when trying to serialize (save) level to level", pName ? pName : "<NULL>");
  664.         }
  665.         ser.Value("numTokens", numTokensSaved);
  666.  
  667.         pSerializer->Release();
  668. }
  669.  
  670. //////////////////////////////////////////////////////////////////////////
  671. void CGameTokenSystem::SerializeReadLevelToLevel()
  672. {
  673.         if (!m_levelToLevelSave)
  674.                 return;
  675.  
  676.         IXmlSerializer* pSerializer = gEnv->pSystem->GetXmlUtils()->CreateXmlSerializer();
  677.         ISerialize* pSer = pSerializer->GetReader(m_levelToLevelSave);
  678.         TSerialize ser = TSerialize(pSer);
  679.  
  680.         uint32 numTokens = 0;
  681.         ser.Value("numTokens", numTokens);
  682.         for (uint32 i = 0; i < numTokens; i++)
  683.         {
  684.                 ser.BeginGroup("Token");
  685.                 string tokenName;
  686.                 ser.Value("name", tokenName);
  687.                 CGameToken* pToken = GetToken(tokenName.c_str());
  688.                 if (pToken)
  689.                         pToken->m_value.Serialize(ser);
  690.                 else
  691.                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_ERROR, "GameTokenSystem. GameToken '%s' was not found when trying to serialize (read) level to level", tokenName.c_str());
  692.                 ser.EndGroup();
  693.         }
  694.  
  695.         pSerializer->Release();
  696.         m_levelToLevelSave = NULL; // this frees it
  697. }
  698.  
  699. //////////////////////////////////////////////////////////////////////////
  700. void CGameTokenSystem::DumpAllTokens()
  701. {
  702.         GameTokensMap::iterator iter(m_pGameTokensMap->begin());
  703.         int i = 0;
  704.         while (iter != m_pGameTokensMap->end())
  705.         {
  706.                 CryLogAlways("#%04d [%s]=[%s]", i, (*iter).second->GetName(), (*iter).second->GetValueAsString());
  707.                 ++iter;
  708.                 ++i;
  709.         }
  710. }
  711.  
  712. //////////////////////////////////////////////////////////////////////////
  713. void CGameTokenSystem::DebugDraw()
  714. {
  715. #ifdef _GAMETOKENSDEBUGINFO
  716.  
  717.         static bool drawnLastFrame = false;
  718.         float color[] = { 1.0f, 1.0f, 1.0f, 1.0f };
  719.  
  720.         if (CGameTokenSystem::m_CVarShowDebugInfo == 0 || CGameTokenSystem::m_CVarShowDebugInfo == 3)
  721.         {
  722.                 drawnLastFrame = false;
  723.                 return;
  724.         }
  725.  
  726.         if (!drawnLastFrame)
  727.                 ClearDebugHistory();
  728.  
  729.         drawnLastFrame = true;
  730.  
  731.         if (gEnv->pConsole->IsOpened())
  732.                 return;
  733.  
  734.         IRenderer* pRenderer = gEnv->pRenderer;
  735.         if (!pRenderer)
  736.                 return;
  737.  
  738.         int linesDrawn = 0;
  739.  
  740.         {
  741.                 TDebugListMap::iterator iter = m_debugList.begin();
  742.                 int i = 0;
  743.                 while (iter != m_debugList.end())
  744.                 {
  745.                         CGameToken* pToken = GetToken(iter->c_str());
  746.  
  747.                         DrawToken(iter->c_str(), GetTokenDebugString(pToken), pToken ? pToken->GetLastChangeTime() : CTimeValue(), i);
  748.  
  749.                         ++iter;
  750.                         ++i;
  751.                 }
  752.                 linesDrawn = i;
  753.         }
  754.  
  755.         {
  756.                 int numHistoryLines = GetHistoryBufferSize();
  757.                 if (numHistoryLines > 0)
  758.                 {
  759.                         string buf;
  760.                         IRenderAuxText::Draw2dLabel(20.0f + m_CVarPosX, 20.0f + m_CVarPosY + 12.0f * (float)linesDrawn, 1.2f, color, false, "---------------HISTORY----------------");
  761.                         linesDrawn++;
  762.                         for (int i = 0; i < numHistoryLines; i++)
  763.                         {
  764.                                 uint index = (m_historyStart + i) % numHistoryLines;
  765.                                 SDebugHistoryEntry& entry = m_debugHistory[index];
  766.                                 DrawToken(entry.tokenName, entry.value, entry.timeChanged, linesDrawn + i);
  767.                         }
  768.                 }
  769.         }
  770.  
  771. #endif
  772. }
  773.  
  774. #ifdef _GAMETOKENSDEBUGINFO
  775.  
  776. //////////////////////////////////////////////////////////////////////////
  777. const char* CGameTokenSystem::GetTokenDebugString(CGameToken* pToken)
  778. {
  779.         if (!pToken)
  780.                 return "<TOKEN NOT FOUND>";
  781.  
  782.         // TODO: this is needed because boolean gametokens change types from bool to string.
  783.         if (pToken->GetType() == eFDT_Bool)
  784.         {
  785.                 bool val = false;
  786.                 pToken->GetValueAs(val);
  787.                 return val ? "true" : "false";
  788.         }
  789.         else
  790.                 return pToken->GetValueAsString();
  791. }
  792.  
  793. //////////////////////////////////////////////////////////////////////////
  794. void CGameTokenSystem::ClearDebugHistory()
  795. {
  796.         m_historyStart = 0;
  797.         m_historyEnd = GetHistoryBufferSize();
  798.         m_oldNumHistoryLines = GetHistoryBufferSize();
  799.         for (int i = 0; i < DBG_HISTORYSIZE; i++)
  800.         {
  801.                 m_debugHistory[i].tokenName.clear();
  802.                 m_debugHistory[i].value.clear();
  803.         }
  804. }
  805.  
  806. //////////////////////////////////////////////////////////////////////////
  807. void CGameTokenSystem::DrawToken(const char* pTokenName, const char* pTokenValue, const CTimeValue& timeChanged, int line)
  808. {
  809.         IRenderer* pRenderer = gEnv->pRenderer;
  810.         float notChanged[] = { 1.0f, 1.0f, 1.0f, 1.0f };
  811.         float changed[] = { 1.0f, 0.0f, 0.0f, 1.0f };
  812.         float color[] = { 0.f, 0.f, 0.f, 0.f };
  813.  
  814.         string buf;
  815.         buf.Format("%s = %s", pTokenName, pTokenValue);
  816.         float dt = (gEnv->pTimer->GetFrameStartTime() - timeChanged).GetSeconds();
  817.  
  818.         const float COLOR_TIME_LAPSE = 10;  // seconds
  819.         {
  820.                 float timeNorm = min(1.f, dt / COLOR_TIME_LAPSE);
  821.                 for (int i = 0; i < 4; i++)
  822.                         color[i] = min(1.f, (timeNorm * notChanged[i] + (1.f - timeNorm) * changed[i]));
  823.         }
  824.  
  825.         IRenderAuxText::Draw2dLabel(20.0f + m_CVarPosX, 20.0f + m_CVarPosY + 12.0f * (float)line, 1.2f, color, false, "%s", buf.c_str());
  826. }
  827.  
  828. //////////////////////////////////////////////////////////////////////////
  829. void CGameTokenSystem::AddTokenToDebugList(const char* pToken)
  830. {
  831.         string tokenName(pToken);
  832.         m_debugList.insert(tokenName);
  833. }
  834.  
  835. //////////////////////////////////////////////////////////////////////////
  836. void CGameTokenSystem::RemoveTokenFromDebugList(const char* pToken)
  837. {
  838.         string tokenName(pToken);
  839.         TDebugListMap::iterator iter = m_debugList.find(tokenName);
  840.         if (iter != m_debugList.end())
  841.                 m_debugList.erase(iter);
  842. }
  843. #endif
  844.  
  845. //////////////////////////////////////////////////////////////////////////
  846. void CGameTokenSystem::GetMemoryStatistics(ICrySizer* s)
  847. {
  848.         SIZER_SUBCOMPONENT_NAME(s, "GameTokenSystem");
  849.         s->Add(*this);
  850.         s->AddObject(m_listeners);
  851.         if (m_pGameTokensMap)
  852.         {
  853.                 s->AddHashMap(*m_pGameTokensMap);
  854.  
  855.                 for (GameTokensMap::iterator iter = m_pGameTokensMap->begin(); iter != m_pGameTokensMap->end(); ++iter)
  856.                 {
  857.                         iter->second->GetMemoryStatistics(s);
  858.                 }
  859.         }
  860. }
  861.  
downloadGameTokenSystem.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