BVB Source Codes

CRYENGINE Show DialogSystem.cpp Source code

Return Download CRYENGINE: download DialogSystem.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:   DialogSystem.cpp
  5. //  Version:     v1.00
  6. //  Created:     07/07/2006 by AlexL
  7. //  Compilers:   Visual Studio.NET
  8. //  Description: Dialog System
  9. // -------------------------------------------------------------------------
  10. //  History:
  11. //
  12. ////////////////////////////////////////////////////////////////////////////
  13. #include "StdAfx.h"
  14. #include "DialogSystem.h"
  15.  
  16. #include "DialogLoader.h"
  17. #include "DialogLoaderMK2.h"
  18. #include "DialogScript.h"
  19. #include "DialogSession.h"
  20. #include "DialogCommon.h"
  21.  
  22. #include "DialogActorContext.h"
  23.  
  24. #include "CryAction.h"
  25.  
  26. #define DIALOG_LIBS_PATH_EXCEL "Libs/Dialogs"
  27. #define DIALOG_LIBS_PATH_MK2   "Libs/Dialogs"
  28.  
  29. int CDialogSystem::sDiaLOGLevel = 0;
  30. int CDialogSystem::sPrecacheSounds = 0;
  31. int CDialogSystem::sLoadSoundSynchronously = 0;
  32. int CDialogSystem::sAutoReloadScripts = 0;
  33. int CDialogSystem::sLoadExcelScripts = 0;
  34. int CDialogSystem::sWarnOnMissingLoc = 0;
  35. ICVar* CDialogSystem::ds_LevelNameOverride = 0;
  36.  
  37. namespace
  38. {
  39. void ScriptReload(IConsoleCmdArgs* pArgs)
  40. {
  41.         CDialogSystem* pDS = CCryAction::GetCryAction()->GetDialogSystem();
  42.         if (pDS)
  43.         {
  44.                 pDS->ReloadScripts();
  45.         }
  46. }
  47.  
  48. ///////////////////////////////////////////////////////////////////////////
  49. void ScriptDump(IConsoleCmdArgs* pArgs)
  50. {
  51.         CDialogSystem* pDS = CCryAction::GetCryAction()->GetDialogSystem();
  52.         if (pDS)
  53.         {
  54.                 int verbosity = 0;
  55.                 if (pArgs->GetArgCount() > 1)
  56.                         verbosity = atoi(pArgs->GetArg(1));
  57.                 pDS->Dump(verbosity);
  58.         }
  59. }
  60.  
  61. ///////////////////////////////////////////////////////////////////////////
  62. void ScriptDumpSessions(IConsoleCmdArgs* pArgs)
  63. {
  64.         CDialogSystem* pDS = CCryAction::GetCryAction()->GetDialogSystem();
  65.         if (pDS)
  66.         {
  67.                 pDS->DumpSessions();
  68.         }
  69. }
  70.  
  71. ///////////////////////////////////////////////////////////////////////////
  72. bool InitCons()
  73. {
  74.         REGISTER_COMMAND("ds_Reload", ScriptReload, VF_NULL, "");
  75.         REGISTER_COMMAND("ds_Dump", ScriptDump, VF_NULL, "");
  76.         REGISTER_COMMAND("ds_DumpSessions", ScriptDumpSessions, VF_NULL, "");
  77.  
  78.         // LogLevel of DiaLOG messages
  79.  
  80.         REGISTER_CVAR2("ds_LogLevel", &CDialogSystem::sDiaLOGLevel, 0, 0, "Set the verbosity of DiaLOG Messages");
  81.         // Precaching of sounds on dialog sounds [0 by default now, until SoundSystem supports un-caching]
  82.         REGISTER_CVAR2("ds_PrecacheSounds", &CDialogSystem::sPrecacheSounds, 0, 0, "Precache sounds on Dialog Begin");
  83.         // Load sounds synchronously (off by default)
  84.         REGISTER_CVAR2("ds_LoadSoundsSync", &CDialogSystem::sLoadSoundSynchronously, 0, 0, "Load Sounds synchronously");
  85.         // Precaching of sounds on dialog sounds [0 by default now, until SoundSystem supports un-caching]
  86.         REGISTER_CVAR2("ds_AutoReloadScripts", &CDialogSystem::sAutoReloadScripts, 0, VF_CHEAT, "Automatically reload DialogScripts when jumping into GameMode from Editor");
  87.         // Load old Excel based scripts
  88.         REGISTER_CVAR2("ds_LoadExcelScripts", &CDialogSystem::sLoadExcelScripts, 1, 0, "Load legacy Excel based dialogs.");
  89.         // Warn on missing Localization entries
  90.         REGISTER_CVAR2("ds_WarnOnMissingLoc", &CDialogSystem::sWarnOnMissingLoc, 1, 0, "Warn on Missing Localization Entries");
  91.  
  92.         // Warn on missing Localization entries
  93.         CDialogSystem::ds_LevelNameOverride = REGISTER_STRING("ds_LevelNameOverride", "", 0,
  94.                                                               "Load dialog assets from the specified level name instead of the current level name."
  95.                                                               "This var gets cleared after level the level is loaded.");
  96.  
  97.         return true;
  98. }
  99. /*
  100.    void ReleaseConsole()
  101.    {
  102.     IConsole* pConsole = gEnv->pConsole;
  103.  
  104.     pConsole->RemoveCommand("ds_Reload");
  105.     pConsole->RemoveCommand("ds_Dump");
  106.     pConsole->RemoveCommand("ds_DumpSessions");
  107.  
  108.     pConsole->UnregisterVariable("ds_LogLevel", true);
  109.     pConsole->UnregisterVariable("ds_PrecacheSounds", true);
  110.     pConsole->UnregisterVariable("ds_LoadSoundsSync", true);
  111.     pConsole->UnregisterVariable("ds_AutoReloadScripts", true);
  112.     pConsole->UnregisterVariable("ds_LoadExcelScripts", true);
  113.     pConsole->UnregisterVariable("ds_PlayerAwareAngle", true);
  114.     pConsole->UnregisterVariable("ds_PlayerAwareDist", true);
  115.     pConsole->UnregisterVariable("ds_PlayerGraceTime", true);
  116.    }
  117.  */
  118. };
  119.  
  120. class CDialogSystem::CDialogScriptIterator : public IDialogScriptIterator
  121. {
  122. public:
  123.         CDialogScriptIterator(CDialogSystem* pDS)
  124.         {
  125.                 m_nRefs = 0;
  126.                 m_cur = pDS->m_dialogScriptMap.begin();
  127.                 m_end = pDS->m_dialogScriptMap.end();
  128.         }
  129.         void AddRef()
  130.         {
  131.                 ++m_nRefs;
  132.         }
  133.         void Release()
  134.         {
  135.                 if (0 == --m_nRefs)
  136.                         delete this;
  137.         }
  138.         bool Next(IDialogScriptIterator::SDialogScript& s)
  139.         {
  140.                 if (m_cur != m_end)
  141.                 {
  142.                         const CDialogScript* pScript = m_cur->second;
  143.                         s.id = pScript->GetID();
  144.                         s.desc = pScript->GetDescription();
  145.                         s.numRequiredActors = pScript->GetNumRequiredActors();
  146.                         s.numLines = pScript->GetNumLines();
  147.                         s.bIsLegacyExcel = pScript->GetVersionFlags() & CDialogScript::VF_EXCEL_BASED;
  148.                         ++m_cur;
  149.                         return true;
  150.                 }
  151.                 else
  152.                 {
  153.                         s.id = 0;
  154.                         s.numRequiredActors = 0;
  155.                         s.numLines = 0;
  156.                         return false;
  157.                 }
  158.         }
  159.  
  160.         int                        m_nRefs;
  161.         TDialogScriptMap::iterator m_cur;
  162.         TDialogScriptMap::iterator m_end;
  163. };
  164.  
  165. ////////////////////////////////////////////////////////////////////////////
  166. CDialogSystem::CDialogSystem()
  167. {
  168.         static bool sInitVars(InitCons());
  169.         m_nextSessionID = 1;
  170.  
  171.         CCryAction::GetCryAction()->GetILevelSystem()->AddListener(this);
  172. }
  173.  
  174. ////////////////////////////////////////////////////////////////////////////
  175. CDialogSystem::~CDialogSystem()
  176. {
  177.         ReleaseSessions();
  178.         ReleaseScripts();
  179.  
  180.         if (CCryAction::GetCryAction()->GetILevelSystem())
  181.                 CCryAction::GetCryAction()->GetILevelSystem()->RemoveListener(this);
  182. }
  183.  
  184. ////////////////////////////////////////////////////////////////////////////
  185. /* virtual */ bool CDialogSystem::Init()
  186. {
  187.         // (MATT) Loading just the dialog for one level works only in Game, but saves a lot of RAM.
  188.         // In Editor it seems very awkward to arrange so lets just load everything {2008/08/20}
  189.         if (gEnv->IsEditor())
  190.                 ReloadScripts();
  191.         return true;
  192. }
  193.  
  194. ////////////////////////////////////////////////////////////////////////////
  195. /* virtual */ void CDialogSystem::Reset(bool bUnload)
  196. {
  197.         m_dialogQueueManager.Reset();
  198.         ReleaseSessions();
  199.         if (bUnload)
  200.                 ReleaseScripts();
  201. }
  202.  
  203. ////////////////////////////////////////////////////////////////////////////
  204. void CDialogSystem::ReleaseScripts()
  205. {
  206.         TDialogScriptMap::iterator iter = m_dialogScriptMap.begin();
  207.         TDialogScriptMap::iterator end = m_dialogScriptMap.end();
  208.         while (iter != end)
  209.         {
  210.                 delete iter->second;
  211.                 ++iter;
  212.         }
  213.         m_dialogScriptMap.clear();
  214. }
  215.  
  216. ////////////////////////////////////////////////////////////////////////////
  217. void CDialogSystem::ReleasePendingDeletes()
  218. {
  219.         if (m_pendingDeleteSessions.empty() == false)
  220.         {
  221.                 TDialogSessionVec::iterator iter = m_pendingDeleteSessions.begin();
  222.                 TDialogSessionVec::iterator end = m_pendingDeleteSessions.end();
  223.                 while (iter != end)
  224.                 {
  225.                         // session MUST not be in m_allSessions! otherwise could be released twice
  226.                         assert(m_allSessions.find((*iter)->GetSessionID()) == m_allSessions.end());
  227.                         (*iter)->Release();
  228.                         ++iter;
  229.                 }
  230.                 stl::free_container(m_pendingDeleteSessions);
  231.         }
  232. }
  233.  
  234. ////////////////////////////////////////////////////////////////////////////
  235. void CDialogSystem::ReleaseSessions()
  236. {
  237.         ReleasePendingDeletes();
  238.         TDialogSessionMap::iterator iter = m_allSessions.begin();
  239.         TDialogSessionMap::iterator end = m_allSessions.end();
  240.         while (iter != end)
  241.         {
  242.                 (*iter).second->Release();
  243.                 ++iter;
  244.         }
  245.         stl::free_container(m_activeSessions);
  246.         stl::free_container(m_allSessions);
  247.         stl::free_container(m_restoreSessions);
  248.  
  249.         CDialogActorContext::ResetStaticData();
  250.  
  251.         m_nextSessionID = 1;
  252. }
  253.  
  254. ////////////////////////////////////////////////////////////////////////////
  255. void CDialogSystem::OnLoadingComplete(ILevelInfo* pLevel)
  256. {
  257.         if (pLevel)
  258.         {
  259.                 const char* levelName = pLevel->GetName();
  260.                 const char* overrideName = ds_LevelNameOverride->GetString();
  261.  
  262.                 if (*overrideName)
  263.                         levelName = overrideName;
  264.  
  265.                 ReloadScripts(levelName);
  266.  
  267.                 ds_LevelNameOverride->ForceSet("");
  268.         }
  269. }
  270.  
  271. ////////////////////////////////////////////////////////////////////////////
  272. /* virtual */ void CDialogSystem::Shutdown()
  273. {
  274.         ReleaseSessions();
  275.         ReleaseScripts();
  276. }
  277.  
  278. ////////////////////////////////////////////////////////////////////////////
  279. /* virtual */ bool CDialogSystem::ReloadScripts(const char* levelName)
  280. {
  281.         LOADING_TIME_PROFILE_SECTION(gEnv->pSystem);
  282.  
  283.         ReleaseSessions();
  284.         ReleaseScripts();
  285.  
  286.         bool bSuccessOld = false;
  287.         bool bSuccessNew = false;
  288.  
  289.         // load old excel based dialogs
  290.         if (sLoadExcelScripts)
  291.         {
  292.                 CDialogLoader loader(this);
  293.  
  294.                 string path = DIALOG_LIBS_PATH_EXCEL;
  295.                 bSuccessOld = loader.LoadScriptsFromPath(path, m_dialogScriptMap);
  296.         }
  297.  
  298.         // load new DialogEditor based dialogs
  299.         {
  300.                 CDialogLoaderMK2 loader(this);
  301.  
  302.                 const string path = DIALOG_LIBS_PATH_MK2;
  303.                 bSuccessNew = loader.LoadScriptsFromPath(path, m_dialogScriptMap, levelName);
  304.  
  305.                 if (!gEnv->IsEditor())
  306.                 {
  307.                         bSuccessNew |= loader.LoadScriptsFromPath(path, m_dialogScriptMap, "All_Levels");
  308.                 }
  309.         }
  310.  
  311.         return bSuccessOld || bSuccessNew;
  312. }
  313.  
  314. ////////////////////////////////////////////////////////////////////////////
  315. const CDialogScript* CDialogSystem::GetScriptByID(const string& scriptID) const
  316. {
  317.         return stl::find_in_map(m_dialogScriptMap, scriptID, 0);
  318. }
  319.  
  320. ////////////////////////////////////////////////////////////////////////////
  321. // Creates a new sessionwith sessionID m_nextSessionID and increases m_nextSessionID
  322. CDialogSystem::SessionID CDialogSystem::CreateSession(const string& scriptID)
  323. {
  324.         CDialogSession* pSession = InternalCreateSession(scriptID, m_nextSessionID);
  325.         if (pSession)
  326.         {
  327.                 ++m_nextSessionID;
  328.                 return pSession->GetSessionID();
  329.         }
  330.         return 0;
  331. }
  332.  
  333. ////////////////////////////////////////////////////////////////////////////
  334. // Uses sessionID for newly allocated session
  335. CDialogSession* CDialogSystem::InternalCreateSession(const string& scriptID, CDialogSystem::SessionID sessionID)
  336. {
  337.         const CDialogScript* pScript = GetScriptByID(scriptID);
  338.         if (pScript == 0)
  339.         {
  340.                 GameWarning("CDialogSystem::CreateSession: DialogScript '%s' unknown.", scriptID.c_str());
  341.                 return 0;
  342.         }
  343.  
  344.         CDialogSession* pSession = new CDialogSession(this, pScript, sessionID);
  345.         std::pair<TDialogSessionMap::iterator, bool> ok = m_allSessions.insert(TDialogSessionMap::value_type(sessionID, pSession));
  346.         if (ok.second == false)
  347.         {
  348.                 assert(false);
  349.                 GameWarning("CDialogSystem::CreateSession: Duplicate SessionID %d", sessionID);
  350.                 delete pSession;
  351.                 pSession = 0;
  352.         }
  353.         return pSession;
  354. }
  355.  
  356. ////////////////////////////////////////////////////////////////////////////
  357. CDialogSession* CDialogSystem::GetSession(CDialogSystem::SessionID id) const
  358. {
  359.         return stl::find_in_map(m_allSessions, id, 0);
  360. }
  361.  
  362. ////////////////////////////////////////////////////////////////////////////
  363. CDialogSession* CDialogSystem::GetActiveSession(CDialogSystem::SessionID id) const
  364. {
  365.         for (TDialogSessionVec::const_iterator it = m_activeSessions.begin(); it != m_activeSessions.end(); ++it)
  366.         {
  367.                 if ((*it)->GetSessionID() == id)
  368.                 {
  369.                         return *it;
  370.                 }
  371.         }
  372.  
  373.         return 0;
  374. }
  375. ////////////////////////////////////////////////////////////////////////////
  376.  
  377. CDialogActorContext* CDialogSystem::GetActiveSessionActorContext(ActorContextID id) const
  378. {
  379.         for (TDialogSessionVec::const_iterator it = m_activeSessions.begin(); it != m_activeSessions.end(); ++it)
  380.         {
  381.                 CDialogSession::CDialogActorContextPtr foundContextWithMatchingID = (*it)->GetContext(id);
  382.                 if (foundContextWithMatchingID)
  383.                 {
  384.                         return foundContextWithMatchingID;
  385.                 }
  386.         }
  387.  
  388.         return 0;
  389. }
  390.  
  391. ////////////////////////////////////////////////////////////////////////////
  392. bool CDialogSystem::DeleteSession(CDialogSystem::SessionID id)
  393. {
  394.         TDialogSessionMap::iterator iter = m_allSessions.find(id);
  395.         if (iter == m_allSessions.end())
  396.                 return false;
  397.         CDialogSession* pSession = iter->second;
  398.         // remove it from the active sessions
  399.         RemoveSession(pSession);
  400.         stl::push_back_unique(m_pendingDeleteSessions, pSession);
  401.         m_allSessions.erase(iter);
  402.         stl::find_and_erase(m_restoreSessions, id); // erase it from sessions which will be restored
  403.         return true;
  404. }
  405.  
  406. ////////////////////////////////////////////////////////////////////////////
  407. bool CDialogSystem::AddSession(CDialogSession* pSession)
  408. {
  409.         return stl::push_back_unique(m_activeSessions, pSession);
  410. }
  411.  
  412. ////////////////////////////////////////////////////////////////////////////
  413. bool CDialogSystem::RemoveSession(CDialogSession* pSession)
  414. {
  415.         return stl::find_and_erase(m_activeSessions, pSession);
  416. }
  417.  
  418. ////////////////////////////////////////////////////////////////////////////
  419. void CDialogSystem::Update(const float dt)
  420. {
  421.         FUNCTION_PROFILER(GetISystem(), PROFILE_ACTION);
  422.  
  423.         RestoreSessions();
  424.  
  425.         if (!m_activeSessions.empty())
  426.         {
  427.                 //original vector can get invalidate if elements are deleted during update calls. therefore we create a copy first
  428.                 TDialogSessionVec activeSessionsCopy(m_activeSessions);
  429.                 for (TDialogSessionVec::const_iterator it = activeSessionsCopy.begin(); it != activeSessionsCopy.end(); ++it)
  430.                 {
  431.                         (*it)->Update(dt);
  432.                 }
  433.         }
  434.  
  435.         ReleasePendingDeletes();
  436.  
  437.         m_dialogQueueManager.Update();
  438. }
  439.  
  440. ///////////////////////////////////////////////////////////////////////////
  441. void CDialogSystem::RestoreSessions()
  442. {
  443.         if (m_restoreSessions.empty() == false)
  444.         {
  445.                 std::vector<SessionID>::iterator iter = m_restoreSessions.begin();
  446.                 std::vector<SessionID>::iterator end = m_restoreSessions.end();
  447.                 while (iter != end)
  448.                 {
  449.                         bool ok = false;
  450.                         CDialogSession* pSession = GetSession(*iter);
  451.                         if (pSession)
  452.                         {
  453.                                 DiaLOG::Log(DiaLOG::eDebugA, "[DIALOG] CDialogSystem::RestoreSessions: Session=%s", pSession->GetDebugName());
  454.                                 ok = pSession->RestoreAndPlay();
  455.                         }
  456.  
  457.                         if (!ok)
  458.                         {
  459.                                 SessionID id = *iter;
  460.                                 GameWarning("[DIALOG] CDialogSystem::Update: Cannot restore session %d", id);
  461.                         }
  462.                         ++iter;
  463.                 }
  464.                 m_restoreSessions.resize(0);
  465.         }
  466. }
  467.  
  468. ////////////////////////////////////////////////////////////////////////////
  469. IDialogScriptIteratorPtr CDialogSystem::CreateScriptIterator()
  470. {
  471.         return new CDialogScriptIterator(this);
  472. }
  473.  
  474. ////////////////////////////////////////////////////////////////////////////
  475. void CDialogSystem::Serialize(TSerialize ser)
  476. {
  477.         m_dialogQueueManager.Serialize(ser);
  478.  
  479.         if (ser.IsWriting())
  480.         {
  481.                 // All Sessions
  482.                 uint32 count = m_allSessions.size();
  483.                 ser.Value("sessionCount", count);
  484.                 for (TDialogSessionMap::const_iterator iter = m_allSessions.begin(); iter != m_allSessions.end(); ++iter)
  485.                 {
  486.                         CDialogSession* pSession = iter->second;
  487.                         ser.BeginGroup("Session");
  488.                         int sessionID = pSession->GetSessionID();
  489.                         ser.Value("id", sessionID);
  490.                         ser.Value("script", pSession->GetScript()->GetID());
  491.                         pSession->Serialize(ser);
  492.                         ser.EndGroup();
  493.                 }
  494.  
  495.                 // Active Sessions: We store the SessionID of active session. They will get restored on Load
  496.                 std::vector<int> temp;
  497.                 temp.reserve(m_activeSessions.size());
  498.                 for (TDialogSessionVec::const_iterator iter = m_activeSessions.begin(); iter != m_activeSessions.end(); ++iter)
  499.                 {
  500.                         temp.push_back((*iter)->GetSessionID());
  501.                 }
  502.                 ser.Value("m_activeSessions", temp);
  503.  
  504.                 // next session id
  505.                 ser.Value("m_nextSessionID", m_nextSessionID);
  506.         }
  507.         else
  508.         {
  509.                 // Delete/Clean all sessions
  510.                 ReleaseSessions();
  511.  
  512.                 // Serialize All Sessions
  513.                 uint32 sessionCount = 0;
  514.                 ser.Value("sessionCount", sessionCount);
  515.                 for (int i = 0; i < sessionCount; ++i)
  516.                 {
  517.                         ser.BeginGroup("Session");
  518.                         int id = 0;
  519.                         string scriptID;
  520.                         ser.Value("id", id);
  521.                         ser.Value("script", scriptID);
  522.                         CDialogSession* pSession = InternalCreateSession(scriptID, id);
  523.                         if (pSession)
  524.                         {
  525.                                 pSession->Serialize(ser);
  526.                         }
  527.                         ser.EndGroup();
  528.                 }
  529.  
  530.                 // Active sessions restore
  531.                 // Make sure that ID's are unique in there
  532.                 std::vector<int> temp;
  533.                 ser.Value("m_activeSessions", temp);
  534.                 std::set<int> tempSet(temp.begin(), temp.end());
  535.                 // good when temp.size() is rather large, otherwise push_back_unique would be better
  536.                 assert(tempSet.size() == temp.size());
  537.                 if (tempSet.size() != temp.size())
  538.                 {
  539.                         GameWarning("[DIALOG] CDialogSystem::Serialize: Active Sessions are not unique!");
  540.                 }
  541.  
  542.                 // Store IDs of Session to be restored. They get restored on 1st Update call
  543.                 m_restoreSessions.insert(m_restoreSessions.end(), tempSet.begin(), tempSet.end());
  544.  
  545.                 // next session id: in case we couldn't recreate a session (script invalid)
  546.                 // the m_nextSessionID should be taken from file
  547.                 int nextSessionID = m_nextSessionID;
  548.                 ser.Value("m_nextSessionID", nextSessionID);
  549.                 assert(nextSessionID >= m_nextSessionID);
  550.                 m_nextSessionID = nextSessionID;
  551.         }
  552. }
  553.  
  554. ///////////////////////////////////////////////////////////////////////////
  555. const char* ToActor(CDialogScript::TActorID id)
  556. {
  557.         switch (id)
  558.         {
  559.         case 0:
  560.                 return "Actor1";
  561.         case 1:
  562.                 return "Actor2";
  563.         case 2:
  564.                 return "Actor3";
  565.         case 3:
  566.                 return "Actor4";
  567.         case 4:
  568.                 return "Actor5";
  569.         case 5:
  570.                 return "Actor6";
  571.         case 6:
  572.                 return "Actor7";
  573.         case 7:
  574.                 return "Actor8";
  575.         case CDialogScript::NO_ACTOR_ID:
  576.                 return "<none>";
  577.         case CDialogScript::STICKY_LOOKAT_RESET_ID:
  578.                 return "<reset>";
  579.         default:
  580.                 return "ActorX";
  581.         }
  582. }
  583.  
  584. ////////////////////////////////////////////////////////////////////////////
  585. void CDialogSystem::Dump(int verbosity)
  586. {
  587.         int i = 0;
  588.         TDialogScriptMap::const_iterator iter = m_dialogScriptMap.begin();
  589.         while (iter != m_dialogScriptMap.end())
  590.         {
  591.                 const CDialogScript* pScript = iter->second;
  592.                 CryLogAlways("Dialog %3d ID='%s' Lines=%d  NumRequiredActors=%d", i, pScript->GetID().c_str(), pScript->GetNumLines(), pScript->GetNumRequiredActors());
  593.                 if (verbosity > 0)
  594.                 {
  595.                         for (int nLine = 0; nLine < pScript->GetNumLines(); ++nLine)
  596.                         {
  597.                                 const CDialogScript::SScriptLine* pLine = pScript->GetLine(nLine);
  598.                                 CryLogAlways("Line%3d: %s | AudioTrigger=%u StopAnim=%u | Facial=%s Reset=%u W=%.2f T=%.2f| Anim=%s [%s] EP=%u | LookAt=%s Sticky=%u Reset=%u | Delay=%.2f",
  599.                                              nLine + 1, ToActor(pLine->m_actor), pLine->m_audioID, pLine->m_flagSoundStopsAnim, pLine->m_facial.c_str(), pLine->m_flagResetFacial, pLine->m_facialWeight, pLine->m_facialFadeTime,
  600.                                              pLine->m_anim.c_str(), pLine->m_flagAGSignal ? "SIG" : "ACT", pLine->m_flagAGEP, ToActor(pLine->m_lookatActor), pLine->m_flagLookAtSticky, pLine->m_flagResetLookAt, pLine->m_delay);
  601.                         }
  602.                 }
  603.                 ++i;
  604.                 ++iter;
  605.         }
  606. }
  607.  
  608. ////////////////////////////////////////////////////////////////////////////
  609. void CDialogSystem::DumpSessions()
  610. {
  611.         // all sessions
  612.         CryLogAlways("[DIALOG] AllSessions: Count=%" PRISIZE_T, m_allSessions.size());
  613.         for (TDialogSessionMap::const_iterator iter = m_allSessions.begin();
  614.              iter != m_allSessions.end(); ++iter)
  615.         {
  616.                 const CDialogSession* pSession = iter->second;
  617.                 CryLogAlways("  Session %d 0x%p Script=%s", pSession->GetSessionID(), pSession, pSession->GetScript()->GetID().c_str());
  618.         }
  619.  
  620.         if (m_activeSessions.empty() == false)
  621.         {
  622.                 CryLogAlways("[DIALOG] ActiveSessions: Count=%" PRISIZE_T, m_activeSessions.size());
  623.                 // active sessions
  624.                 for (TDialogSessionVec::const_iterator iter = m_activeSessions.begin();
  625.                      iter != m_activeSessions.end(); ++iter)
  626.                 {
  627.                         const CDialogSession* pSession = *iter;
  628.                         CryLogAlways("  Session %d 0x%p Script=%s", pSession->GetSessionID(), pSession, pSession->GetScript()->GetID().c_str());
  629.                 }
  630.         }
  631.  
  632.         // pending delete sessions
  633.         if (m_pendingDeleteSessions.empty() == false)
  634.         {
  635.                 CryLogAlways("[DIALOG] PendingDelete: Count=%" PRISIZE_T, m_pendingDeleteSessions.size());
  636.                 // active sessions
  637.                 for (TDialogSessionVec::const_iterator iter = m_pendingDeleteSessions.begin();
  638.                      iter != m_pendingDeleteSessions.end(); ++iter)
  639.                 {
  640.                         const CDialogSession* pSession = *iter;
  641.                         CryLogAlways("  Session %d 0x%p Script=%s", pSession->GetSessionID(), pSession, pSession->GetScript()->GetID().c_str());
  642.                 }
  643.         }
  644.         // restore sessions
  645.         if (m_restoreSessions.empty() == false)
  646.         {
  647.                 CryLogAlways("[DIALOG] RestoreSessions: Count=%" PRISIZE_T, m_restoreSessions.size());
  648.                 for (std::vector<SessionID>::const_iterator iter = m_restoreSessions.begin();
  649.                      iter != m_restoreSessions.end(); ++iter)
  650.                 {
  651.                         SessionID id = *iter;
  652.                         CryLogAlways("  Session %d", id);
  653.                 }
  654.         }
  655. }
  656.  
  657. ////////////////////////////////////////////////////////////////////////////
  658. bool CDialogSystem::IsEntityInDialog(EntityId entityId) const
  659. {
  660.         CDialogScript::TActorID actorID;
  661.         CDialogSystem::SessionID sessionID;
  662.         return FindSessionAndActorForEntity(entityId, sessionID, actorID);
  663. }
  664.  
  665. ////////////////////////////////////////////////////////////////////////////
  666. bool CDialogSystem::FindSessionAndActorForEntity(EntityId entityId, CDialogSystem::SessionID& outSessionID, CDialogScript::TActorID& outActorId) const
  667. {
  668.         TDialogSessionVec::const_iterator iter = m_activeSessions.begin();
  669.         TDialogSessionVec::const_iterator end = m_activeSessions.end();
  670.  
  671.         CDialogScript::TActorID actorID;
  672.         while (iter != end)
  673.         {
  674.                 const CDialogSession* pSession = *iter;
  675.                 actorID = pSession->GetActorIdForEntity(entityId);
  676.                 if (actorID != CDialogScript::NO_ACTOR_ID)
  677.                 {
  678.                         outSessionID = pSession->GetSessionID();
  679.                         outActorId = actorID;
  680.                         return true;
  681.                 }
  682.                 ++iter;
  683.         }
  684.  
  685.         outSessionID = 0;
  686.         outActorId = CDialogScript::NO_ACTOR_ID;
  687.         return false;
  688. }
  689.  
  690. ///////////////////////////////////////////////////////////////////////////
  691. void CDialogSystem::GetMemoryStatistics(ICrySizer* pSizer)
  692. {
  693.         SIZER_SUBCOMPONENT_NAME(pSizer, "DialogSystem");
  694.         pSizer->AddObject(m_dialogScriptMap);
  695.         pSizer->AddObject(m_allSessions);
  696.         pSizer->AddObject(m_activeSessions);
  697.         pSizer->AddObject(m_pendingDeleteSessions);
  698.         pSizer->AddObject(m_restoreSessions);
  699. }
  700.  
downloadDialogSystem.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