BVB Source Codes

CRYENGINE Show GameTokenNode.cpp Source code

Return Download CRYENGINE: download GameTokenNode.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 "CryAction.h"
  5.  
  6. #include <CryGame/IGameTokens.h>
  7. #include <CryFlowGraph/IFlowBaseNode.h>
  8.  
  9. namespace
  10. {
  11. IGameTokenSystem* GetIGameTokenSystem()
  12. {
  13.         CCryAction* pCryAction = CCryAction::GetCryAction();
  14.         return pCryAction ? pCryAction->GetIGameTokenSystem() : NULL;
  15. }
  16.  
  17. void WarningGameTokenNotFound(const char* place, const char* tokenName)
  18. {
  19.         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_ERROR, "[flow] %s: cannot find gametoken: '%s'.", place, tokenName);
  20. }
  21.  
  22. IGameToken* GetGameToken(IFlowNode::SActivationInfo* pActInfo, const string& tokenName, bool bForceCreate)
  23. {
  24.         if (tokenName.empty())
  25.                 return NULL;
  26.  
  27.         IGameToken* pToken = GetIGameTokenSystem()->FindToken(tokenName.c_str());
  28.         if (!pToken)
  29.         {
  30.                 // try graph token instead:
  31.                 string name = pActInfo->pGraph->GetGlobalNameForGraphToken(tokenName);
  32.  
  33.                 pToken = GetIGameTokenSystem()->FindToken(name.c_str());
  34.                 assert(!pToken || pToken->GetFlags() & EGAME_TOKEN_GRAPHVARIABLE);
  35.  
  36.                 if (!pToken && bForceCreate)
  37.                         pToken = GetIGameTokenSystem()->SetOrCreateToken(tokenName.c_str(), TFlowInputData(string("<undefined>"), false));
  38.         }
  39.  
  40.         if (!pToken)
  41.         {
  42.                 WarningGameTokenNotFound("SetGameTokenFlowNode", tokenName.c_str());
  43.         }
  44.  
  45.         return pToken;
  46. }
  47.  
  48. const int bForceCreateDefault = false;   // create non-existing game tokens, default false for the moment
  49. };
  50.  
  51. class CSetGameTokenFlowNode : public CFlowBaseNode<eNCT_Instanced>
  52. {
  53. public:
  54.         CSetGameTokenFlowNode(SActivationInfo* pActInfo) : m_pCachedToken(NULL)
  55.         {
  56.         }
  57.  
  58.         IFlowNodePtr Clone(SActivationInfo* pActInfo)
  59.         {
  60.                 return new CSetGameTokenFlowNode(pActInfo);
  61.         }
  62.  
  63.         virtual void Serialize(SActivationInfo*, TSerialize ser)
  64.         {
  65.                 if (ser.IsReading()) // forces re-caching
  66.                         m_pCachedToken = 0;
  67.         }
  68.  
  69.         void GetConfiguration(SFlowNodeConfig& config)
  70.         {
  71.                 static const SInputPortConfig in_config[] = {
  72.                         InputPortConfig_Void("Trigger",            _HELP("Trigger this input to actually set the game token value"), _HELP("Trigger")),
  73.                         InputPortConfig<string>("gametoken_Token", _HELP("Game token to set"),                                       _HELP("Token")),
  74.                         InputPortConfig<string>("Value",           _HELP("Value to set")),
  75.                         { 0 }
  76.                 };
  77.                 static const SOutputPortConfig out_config[] = {
  78.                         OutputPortConfig_AnyType("OutValue", _HELP("Value which was set (debug)")),
  79.                         { 0 }
  80.                 };
  81.                 config.sDescription = _HELP("Set the value of a game token");
  82.                 config.pInputPorts = in_config;
  83.                 config.pOutputPorts = out_config;
  84.                 config.nFlags |= EFLN_AISEQUENCE_SUPPORTED;
  85.                 config.SetCategory(EFLN_APPROVED);
  86.         }
  87.  
  88.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  89.         {
  90.                 switch (event)
  91.                 {
  92.                 case eFE_Initialize:
  93.                         m_pCachedToken = 0;
  94.                         break;
  95.                 case eFE_Activate:
  96.                         {
  97.                                 if (IsPortActive(pActInfo, 1))
  98.                                 {
  99.                                         CacheToken(pActInfo);
  100.                                 }
  101.                                 if (IsPortActive(pActInfo, 0))
  102.                                 {
  103.                                         if (m_pCachedToken == NULL)
  104.                                                 CacheToken(pActInfo);
  105.  
  106.                                         if (m_pCachedToken != NULL)
  107.                                         {
  108.                                                 m_pCachedToken->SetValue(GetPortAny(pActInfo, 2));
  109.                                                 TFlowInputData data;
  110.                                                 m_pCachedToken->GetValue(data);
  111.                                                 ActivateOutput(pActInfo, 0, data);
  112.                                         }
  113.                                 }
  114.                         }
  115.                         break;
  116.                 }
  117.         }
  118.  
  119.         virtual void GetMemoryUsage(ICrySizer* s) const
  120.         {
  121.                 s->Add(*this);
  122.         }
  123.  
  124. private:
  125.         void CacheToken(SActivationInfo* pActInfo, bool bForceCreate = bForceCreateDefault)
  126.         {
  127.                 string tokenName = GetPortString(pActInfo, 1);
  128.                 m_pCachedToken = GetGameToken(pActInfo, tokenName, bForceCreate);
  129.         }
  130.  
  131. private:
  132.         IGameToken* m_pCachedToken;
  133. };
  134.  
  135. class CGetGameTokenFlowNode : public CFlowBaseNode<eNCT_Instanced>
  136. {
  137. public:
  138.         CGetGameTokenFlowNode(SActivationInfo* pActInfo) : m_pCachedToken(NULL)
  139.         {
  140.         }
  141.  
  142.         IFlowNodePtr Clone(SActivationInfo* pActInfo)
  143.         {
  144.                 return new CGetGameTokenFlowNode(pActInfo);
  145.         }
  146.  
  147.         virtual void Serialize(SActivationInfo*, TSerialize ser)
  148.         {
  149.                 if (ser.IsReading()) // forces re-caching
  150.                         m_pCachedToken = 0;
  151.         }
  152.  
  153.         void GetConfiguration(SFlowNodeConfig& config)
  154.         {
  155.                 static const SInputPortConfig in_config[] = {
  156.                         InputPortConfig_Void("Trigger",            _HELP("Trigger this input to actually get the game token value"), _HELP("Trigger")),
  157.                         InputPortConfig<string>("gametoken_Token", _HELP("Game token to set"),                                       _HELP("Token")),
  158.                         { 0 }
  159.                 };
  160.                 static const SOutputPortConfig out_config[] = {
  161.                         OutputPortConfig_AnyType("OutValue", _HELP("Value of the game token")),
  162.                         { 0 }
  163.                 };
  164.                 config.sDescription = _HELP("Get the value of a game token");
  165.                 config.pInputPorts = in_config;
  166.                 config.pOutputPorts = out_config;
  167.                 config.nFlags |= EFLN_AISEQUENCE_SUPPORTED;
  168.                 config.SetCategory(EFLN_APPROVED);
  169.         }
  170.  
  171.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  172.         {
  173.                 switch (event)
  174.                 {
  175.                 case eFE_Initialize:
  176.                         m_pCachedToken = 0;
  177.                         break;
  178.                 case eFE_Activate:
  179.                         {
  180.                                 if (IsPortActive(pActInfo, 1))
  181.                                 {
  182.                                         CacheToken(pActInfo);
  183.                                 }
  184.                                 if (IsPortActive(pActInfo, 0))
  185.                                 {
  186.                                         if (m_pCachedToken == NULL)
  187.                                                 CacheToken(pActInfo);
  188.  
  189.                                         if (m_pCachedToken != NULL)
  190.                                         {
  191.                                                 TFlowInputData data;
  192.                                                 m_pCachedToken->GetValue(data);
  193.                                                 ActivateOutput(pActInfo, 0, data);
  194.                                         }
  195.                                 }
  196.                         }
  197.                         break;
  198.                 }
  199.         }
  200.  
  201.         virtual void GetMemoryUsage(ICrySizer* s) const
  202.         {
  203.                 s->Add(*this);
  204.         }
  205.  
  206. private:
  207.         void CacheToken(SActivationInfo* pActInfo, bool bForceCreate = bForceCreateDefault)
  208.         {
  209.                 string name = GetPortString(pActInfo, 1);
  210.                 m_pCachedToken = GetGameToken(pActInfo, name, bForceCreate);
  211.         }
  212.  
  213. private:
  214.         IGameToken* m_pCachedToken;
  215. };
  216.  
  217. class CCheckGameTokenFlowNode : public CFlowBaseNode<eNCT_Instanced>
  218. {
  219. public:
  220.         CCheckGameTokenFlowNode(SActivationInfo* pActInfo) : m_pCachedToken(NULL)
  221.         {
  222.         }
  223.  
  224.         IFlowNodePtr Clone(SActivationInfo* pActInfo)
  225.         {
  226.                 return new CCheckGameTokenFlowNode(pActInfo);
  227.         }
  228.  
  229.         virtual void Serialize(SActivationInfo*, TSerialize ser)
  230.         {
  231.                 if (ser.IsReading()) // forces re-caching
  232.                         m_pCachedToken = 0;
  233.         }
  234.  
  235.         void GetConfiguration(SFlowNodeConfig& config)
  236.         {
  237.                 static const SInputPortConfig in_config[] = {
  238.                         InputPortConfig_Void("Trigger",            _HELP("Trigger this input to actually get the game token value"), _HELP("Trigger")),
  239.                         InputPortConfig<string>("gametoken_Token", _HELP("Game token to set"),                                       _HELP("Token")),
  240.                         InputPortConfig<string>("CheckValue",      _HELP("Value to compare the token with")),
  241.                         { 0 }
  242.                 };
  243.                 static const SOutputPortConfig out_config[] = {
  244.                         OutputPortConfig_AnyType("OutValue", _HELP("Value of the token")),
  245.                         OutputPortConfig<bool>("Result",     _HELP("TRUE if equals, FALSE otherwise")),
  246.                         OutputPortConfig_Void("True",        _HELP("Triggered if equal")),
  247.                         OutputPortConfig_Void("False",       _HELP("Triggered if not equal")),
  248.                         { 0 }
  249.                 };
  250.                 config.sDescription = _HELP("Check if the value of a game token equals to a value");
  251.                 config.pInputPorts = in_config;
  252.                 config.pOutputPorts = out_config;
  253.                 config.nFlags |= EFLN_AISEQUENCE_SUPPORTED;
  254.                 config.SetCategory(EFLN_APPROVED);
  255.         }
  256.  
  257.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  258.         {
  259.                 switch (event)
  260.                 {
  261.                 case eFE_Initialize:
  262.                         m_pCachedToken = 0;
  263.                         break;
  264.                 case eFE_Activate:
  265.                         {
  266.                                 if (IsPortActive(pActInfo, 1))
  267.                                 {
  268.                                         CacheToken(pActInfo);
  269.                                 }
  270.                                 if (IsPortActive(pActInfo, 0))
  271.                                 {
  272.                                         if (m_pCachedToken == NULL)
  273.                                                 CacheToken(pActInfo);
  274.  
  275.                                         if (m_pCachedToken != NULL)
  276.                                         {
  277.                                                 // now this is a messy thing.
  278.                                                 // we use TFlowInputData to do all the work, because the
  279.                                                 // game tokens uses them as well.
  280.                                                 // does for the same values we get the same converted strings
  281.                                                 TFlowInputData tokenData;
  282.                                                 m_pCachedToken->GetValue(tokenData);
  283.                                                 TFlowInputData checkData(tokenData);
  284.                                                 checkData.SetValueWithConversion(GetPortString(pActInfo, 2));
  285.                                                 string tokenString, checkString;
  286.                                                 tokenData.GetValueWithConversion(tokenString);
  287.                                                 checkData.GetValueWithConversion(checkString);
  288.                                                 ActivateOutput(pActInfo, 0, tokenData);
  289.                                                 bool equal = tokenString.compareNoCase(checkString) == 0;
  290.                                                 ActivateOutput(pActInfo, 1, equal);
  291.                                                 // trigger either the true or false port depending on comparism
  292.                                                 ActivateOutput(pActInfo, 3 - static_cast<int>(equal), true);
  293.                                         }
  294.                                 }
  295.                         }
  296.                         break;
  297.                 }
  298.         }
  299.  
  300.         virtual void GetMemoryUsage(ICrySizer* s) const
  301.         {
  302.                 s->Add(*this);
  303.         }
  304.  
  305. private:
  306.         void CacheToken(SActivationInfo* pActInfo, bool bForceCreate = bForceCreateDefault)
  307.         {
  308.                 string name = GetPortString(pActInfo, 1);
  309.                 m_pCachedToken = GetGameToken(pActInfo, name, bForceCreate);
  310.         }
  311.  
  312. private:
  313.         IGameToken* m_pCachedToken;
  314. };
  315.  
  316. class CGameTokenCheckMultiFlowNode : public CFlowBaseNode<eNCT_Instanced>
  317. {
  318. public:
  319.         CGameTokenCheckMultiFlowNode(SActivationInfo* pActInfo) : m_pCachedToken(NULL)
  320.         {
  321.         }
  322.  
  323.         enum
  324.         {
  325.                 INP_TRIGGER = 0,
  326.                 INP_GAMETOKEN,
  327.                 INP_FIRST_VALUE,
  328.                 INP_NUM_VALUES = 8
  329.         };
  330.  
  331.         enum
  332.         {
  333.                 OUT_VALUE = 0,
  334.                 OUT_ONE_TRUE,
  335.                 OUT_ALL_FALSE
  336.         };
  337.  
  338.         IFlowNodePtr Clone(SActivationInfo* pActInfo)
  339.         {
  340.                 return new CGameTokenCheckMultiFlowNode(pActInfo);
  341.         }
  342.  
  343.         virtual void Serialize(SActivationInfo*, TSerialize ser)
  344.         {
  345.                 if (ser.IsReading()) // forces re-caching
  346.                         m_pCachedToken = 0;
  347.         }
  348.  
  349.         void GetConfiguration(SFlowNodeConfig& config)
  350.         {
  351.                 static const SInputPortConfig in_config[] = {
  352.                         InputPortConfig_Void("Trigger",            _HELP("Trigger this input to perform the check"), _HELP("Trigger")),
  353.                         InputPortConfig<string>("gametoken_Token", _HELP("Game token to check"),                     _HELP("Token")),
  354.                         InputPortConfig<string>("Value1",          _HELP("Value to compare the token with")),
  355.                         InputPortConfig<string>("Value2",          _HELP("Value to compare the token with")),
  356.                         InputPortConfig<string>("Value3",          _HELP("Value to compare the token with")),
  357.                         InputPortConfig<string>("Value4",          _HELP("Value to compare the token with")),
  358.                         InputPortConfig<string>("Value5",          _HELP("Value to compare the token with")),
  359.                         InputPortConfig<string>("Value6",          _HELP("Value to compare the token with")),
  360.                         InputPortConfig<string>("Value7",          _HELP("Value to compare the token with")),
  361.                         InputPortConfig<string>("Value8",          _HELP("Value to compare the token with")),
  362.                         { 0 }
  363.                 };
  364.                 static const SOutputPortConfig out_config[] = {
  365.                         OutputPortConfig_AnyType("OutValue", _HELP("Value of the token")),
  366.                         OutputPortConfig_Void("One_True",    _HELP("Triggered if the token is equal to at least one of the values")),
  367.                         OutputPortConfig_Void("All_False",   _HELP("Triggered if no given value is equal to the token")),
  368.                         { 0 }
  369.                 };
  370.                 config.sDescription = _HELP("Check if a game token equals to any of a list of values");
  371.                 config.pInputPorts = in_config;
  372.                 config.pOutputPorts = out_config;
  373.                 config.nFlags |= EFLN_AISEQUENCE_SUPPORTED;
  374.                 config.SetCategory(EFLN_APPROVED);
  375.         }
  376.  
  377.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  378.         {
  379.                 switch (event)
  380.                 {
  381.                 case eFE_Initialize:
  382.                         m_pCachedToken = 0;
  383.                         break;
  384.                 case eFE_Activate:
  385.                         {
  386.                                 if (IsPortActive(pActInfo, INP_GAMETOKEN))
  387.                                 {
  388.                                         CacheToken(pActInfo);
  389.                                 }
  390.                                 if (IsPortActive(pActInfo, INP_TRIGGER))
  391.                                 {
  392.                                         if (m_pCachedToken == NULL)
  393.                                                 CacheToken(pActInfo);
  394.  
  395.                                         if (m_pCachedToken != NULL)
  396.                                         {
  397.                                                 // now this is a messy thing.
  398.                                                 // we use TFlowInputData to do all the work, because the
  399.                                                 // game tokens uses them as well.
  400.                                                 // does for the same values we get the same converted strings
  401.                                                 TFlowInputData tokenData;
  402.                                                 m_pCachedToken->GetValue(tokenData);
  403.                                                 TFlowInputData checkData(tokenData);
  404.  
  405.                                                 ActivateOutput(pActInfo, OUT_VALUE, tokenData);
  406.  
  407.                                                 string tokenString, checkString;
  408.                                                 tokenData.GetValueWithConversion(tokenString);
  409.  
  410.                                                 bool bAnyTrue = false;
  411.  
  412.                                                 for (int i = 0; i < INP_NUM_VALUES; i++)
  413.                                                 {
  414.                                                         TFlowInputData chkData(tokenData);
  415.                                                         checkString = GetPortString(pActInfo, INP_FIRST_VALUE + i);
  416.                                                         if (!checkString.empty())
  417.                                                         {
  418.                                                                 chkData.SetValueWithConversion(checkString);
  419.                                                                 chkData.GetValueWithConversion(checkString);  // this double conversion is to correctly manage cases like "true" strings vs bool tokens
  420.                                                                 bAnyTrue |= (tokenString.compareNoCase(checkString) == 0);
  421.                                                         }
  422.                                                 }
  423.  
  424.                                                 if (bAnyTrue)
  425.                                                         ActivateOutput(pActInfo, OUT_ONE_TRUE, true);
  426.                                                 else
  427.                                                         ActivateOutput(pActInfo, OUT_ALL_FALSE, true);
  428.                                         }
  429.                                 }
  430.                         }
  431.                         break;
  432.                 }
  433.         }
  434.  
  435.         virtual void GetMemoryUsage(ICrySizer* s) const
  436.         {
  437.                 s->Add(*this);
  438.         }
  439.  
  440. private:
  441.         void CacheToken(SActivationInfo* pActInfo, bool bForceCreate = bForceCreateDefault)
  442.         {
  443.                 string name = GetPortString(pActInfo, 1);
  444.                 m_pCachedToken = GetGameToken(pActInfo, name, bForceCreate);
  445.         }
  446.  
  447. private:
  448.         IGameToken* m_pCachedToken;
  449. };
  450.  
  451. class CGameTokenFlowNode : public CFlowBaseNode<eNCT_Instanced>, public IGameTokenEventListener
  452. {
  453.         enum EInputs
  454.         {
  455.                 eIN_Gametoken = 0,
  456.                 eIn_CampareString
  457.         };
  458.  
  459.         enum EOutputs
  460.         {
  461.                 eOUT_GametokenValue = 0,
  462.                 eOUT_EqualsTrue,
  463.                 eOUT_EqualsFalse,
  464.                 eOUT_Equals
  465.         };
  466.  
  467. public:
  468.         CGameTokenFlowNode(SActivationInfo* pActInfo) : m_pCachedToken(0), m_actInfo(*pActInfo)
  469.         {
  470.         }
  471.  
  472.         ~CGameTokenFlowNode()
  473.         {
  474.                 Unregister();
  475.         }
  476.  
  477.         IFlowNodePtr Clone(SActivationInfo* pActInfo)
  478.         {
  479.                 return new CGameTokenFlowNode(pActInfo);
  480.         }
  481.  
  482.         virtual void Serialize(SActivationInfo* pActInfo, TSerialize ser)
  483.         {
  484.                 if (ser.IsReading())
  485.                 {
  486.                         // recache and register at token
  487.                         CacheToken(pActInfo);
  488.                 }
  489.         }
  490.  
  491.         void GetConfiguration(SFlowNodeConfig& config)
  492.         {
  493.                 static const SInputPortConfig in_config[] = {
  494.                         InputPortConfig<string>("gametoken_Token", _HELP("GameToken to set/get"), _HELP("Token")),
  495.                         InputPortConfig<string>("compare_Value",   _HELP("Value to compare to"),  _HELP("CompareTo")),
  496.                         { 0 }
  497.                 };
  498.                 static const SOutputPortConfig out_config[] = {
  499.                         OutputPortConfig_AnyType("Out",         _HELP("Outputs the token's value on every change"),                      _HELP("Output")),
  500.                         OutputPortConfig_AnyType("Equal True",  _HELP("Outputs when the token's value equals the checked input."),       _HELP("Equal")),
  501.                         OutputPortConfig_AnyType("Equal False", _HELP("Outputs when the token's value is not equal the checked input."), _HELP("Not Equal")),
  502.                         OutputPortConfig<bool>("Equals",        _HELP("Outputs the result of the equality check."),                      _HELP("Equals")),
  503.                         { 0 }
  504.                 };
  505.                 config.sDescription = _HELP("GameToken set/get");
  506.                 config.pInputPorts = in_config;
  507.                 config.pOutputPorts = out_config;
  508.                 config.nFlags |= EFLN_AISEQUENCE_SUPPORTED;
  509.                 config.SetCategory(EFLN_APPROVED);
  510.         }
  511.  
  512.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  513.         {
  514.                 switch (event)
  515.                 {
  516.                 case eFE_Initialize:
  517.                 case eFE_Activate:
  518.                         {
  519.                                 if (IsPortActive(pActInfo, eIN_Gametoken)) // Token port
  520.                                 {
  521.                                         CacheToken(pActInfo);
  522.                                         if (m_pCachedToken != 0)
  523.                                         {
  524.                                                 TFlowInputData data;
  525.                                                 m_pCachedToken->GetValue(data);
  526.                                                 ActivateOutput(pActInfo, eOUT_GametokenValue, data);
  527.                                         }
  528.                                 }
  529.                                 if (IsPortActive(pActInfo, eIn_CampareString)) // comparison string port
  530.                                 {
  531.                                         m_sComparisonString = GetPortString(pActInfo, eIn_CampareString);
  532.                                 }
  533.                         }
  534.                         break;
  535.                 }
  536.         }
  537.  
  538.         virtual void GetMemoryUsage(ICrySizer* s) const
  539.         {
  540.                 s->Add(*this);
  541.         }
  542. private:
  543.         void OnGameTokenEvent(EGameTokenEvent event, IGameToken* pGameToken)
  544.         {
  545.                 assert(pGameToken == m_pCachedToken);
  546.                 if (event == EGAMETOKEN_EVENT_CHANGE)
  547.                 {
  548.                         TFlowInputData data;
  549.                         m_pCachedToken->GetValue(data);
  550.                         ActivateOutput(&m_actInfo, eOUT_GametokenValue, data);
  551.  
  552.                         // now this is a messy thing.
  553.                         // we use TFlowInputData to do all the work, because the
  554.                         // game tokens uses them as well.
  555.                         TFlowInputData checkData(data);
  556.                         string tokenString;
  557.                         data.GetValueWithConversion(tokenString);
  558.                         bool equal = (tokenString.compareNoCase(m_sComparisonString) == 0);
  559.                         ActivateOutput(&m_actInfo, equal ? eOUT_EqualsTrue : eOUT_EqualsFalse, true);
  560.                         ActivateOutput(&m_actInfo, eOUT_Equals, equal);
  561.                 }
  562.                 else if (event == EGAMETOKEN_EVENT_DELETE)
  563.                 {
  564.                         // no need to unregister
  565.                         m_pCachedToken = 0;
  566.                 }
  567.         }
  568.  
  569.         void Register()
  570.         {
  571.                 IGameTokenSystem* pGTSys = GetIGameTokenSystem();
  572.                 if (m_pCachedToken && pGTSys)
  573.                         pGTSys->RegisterListener(m_pCachedToken->GetName(), this);
  574.         }
  575.  
  576.         void Unregister()
  577.         {
  578.                 IGameTokenSystem* pGTSys = GetIGameTokenSystem();
  579.                 if (m_pCachedToken && pGTSys)
  580.                 {
  581.                         pGTSys->UnregisterListener(m_pCachedToken->GetName(), this);
  582.                         m_pCachedToken = 0;
  583.                 }
  584.         }
  585.  
  586.         void CacheToken(SActivationInfo* pActInfo, bool bForceCreate = bForceCreateDefault)
  587.         {
  588.                 Unregister();
  589.  
  590.                 string tokenName = GetPortString(pActInfo, eIN_Gametoken);
  591.                 m_pCachedToken = GetGameToken(pActInfo, tokenName, bForceCreate);
  592.  
  593.                 if (m_pCachedToken)
  594.                         Register();
  595.         }
  596.  
  597. private:
  598.         SActivationInfo m_actInfo;
  599.         IGameToken*     m_pCachedToken;
  600.         string          m_sComparisonString;
  601. };
  602.  
  603. class CModifyGameTokenFlowNode : public CFlowBaseNode<eNCT_Instanced>
  604. {
  605. public:
  606.         CModifyGameTokenFlowNode(SActivationInfo* pActInfo) : m_pCachedToken(NULL)
  607.         {
  608.         }
  609.  
  610.         IFlowNodePtr Clone(SActivationInfo* pActInfo)
  611.         {
  612.                 return new CModifyGameTokenFlowNode(pActInfo);
  613.         }
  614.  
  615.         virtual void Serialize(SActivationInfo*, TSerialize ser)
  616.         {
  617.                 if (ser.IsReading()) // forces re-caching
  618.                         m_pCachedToken = 0;
  619.         }
  620.  
  621.         enum EOperation
  622.         {
  623.                 EOP_SET = 0,
  624.                 EOP_ADD,
  625.                 EOP_SUB,
  626.                 EOP_MUL,
  627.                 EOP_DIV
  628.         };
  629.  
  630.         enum EType
  631.         {
  632.                 ET_BOOL = 0,
  633.                 ET_INT,
  634.                 ET_FLOAT,
  635.                 ET_VEC3,
  636.                 ET_STRING
  637.         };
  638.  
  639.         template<class Type>
  640.         struct Helper
  641.         {
  642.                 Helper(TFlowInputData& value, const TFlowInputData& operand)
  643.                 {
  644.                         Init(value, operand);
  645.                 }
  646.  
  647.                 bool Init(TFlowInputData& value, const TFlowInputData& operand)
  648.                 {
  649.                         m_ok = value.GetValueWithConversion(m_value);
  650.                         m_ok &= operand.GetValueWithConversion(m_operand);
  651.                         return m_ok;
  652.                 }
  653.  
  654.                 bool m_ok;
  655.                 Type m_value;
  656.                 Type m_operand;
  657.  
  658.         };
  659.  
  660.         template<class Type> bool not_zero(Type& val)          { return true; }
  661.         bool                      not_zero(int& val)           { return val != 0; }
  662.         bool                      not_zero(float& val)         { return val != 0.0f; }
  663.  
  664.         template<class Type> void op_set(Helper<Type>& data)   { if (data.m_ok) data.m_value = data.m_operand; }
  665.         template<class Type> void op_add(Helper<Type>& data)   { if (data.m_ok) data.m_value += data.m_operand; }
  666.         template<class Type> void op_sub(Helper<Type>& data)   { if (data.m_ok) data.m_value -= data.m_operand; }
  667.         template<class Type> void op_mul(Helper<Type>& data)   { if (data.m_ok) data.m_value *= data.m_operand; }
  668.         template<class Type> void op_div(Helper<Type>& data)   { if (data.m_ok && not_zero(data.m_operand)) data.m_value /= data.m_operand; }
  669.  
  670.         void                      op_div(Helper<string>& data) {};
  671.         void                      op_mul(Helper<string>& data) {};
  672.         void                      op_sub(Helper<string>& data) {};
  673.         void                      op_mul(Helper<Vec3>& data)   {};
  674.         void                      op_div(Helper<Vec3>& data)   {};
  675.  
  676.         void                      op_add(Helper<bool>& data)   {};
  677.         void                      op_sub(Helper<bool>& data)   {};
  678.         void                      op_div(Helper<bool>& data)   {};
  679.         void                      op_mul(Helper<bool>& data)   {};
  680.  
  681.         template<class Type> void DoOp(EOperation op, Helper<Type>& data)
  682.         {
  683.                 switch (op)
  684.                 {
  685.                 case EOP_SET:
  686.                         op_set(data);
  687.                         break;
  688.                 case EOP_ADD:
  689.                         op_add(data);
  690.                         break;
  691.                 case EOP_SUB:
  692.                         op_sub(data);
  693.                         break;
  694.                 case EOP_MUL:
  695.                         op_mul(data);
  696.                         break;
  697.                 case EOP_DIV:
  698.                         op_div(data);
  699.                         break;
  700.                 }
  701.         }
  702.  
  703.         void GetConfiguration(SFlowNodeConfig& config)
  704.         {
  705.                 static const SInputPortConfig in_config[] = {
  706.                         InputPortConfig_Void("Trigger",            _HELP("Trigger this input to actually get the game token value"), _HELP("Trigger")),
  707.                         InputPortConfig<string>("gametoken_Token", _HELP("Game token to set"),                                       _HELP("Token")),
  708.                         InputPortConfig<int>("Op",                 EOP_SET,                                                          _HELP("Operation token = token OP value"),_HELP("Operation"),_UICONFIG("enum_int:Set=0,Add=1,Sub=2,Mul=3,Div=4")),
  709.                         InputPortConfig<int>("Type",               ET_STRING,                                                        _HELP("Type"),                            _HELP("Type"),  _UICONFIG("enum_int:Bool=0,Int=1,Float=2,Vec3=3,String=4")),
  710.                         InputPortConfig<string>("Value",           _HELP("Value to operate with")),
  711.                         { 0 }
  712.                 };
  713.                 static const SOutputPortConfig out_config[] = {
  714.                         OutputPortConfig_AnyType("OutValue", _HELP("Value of the token")),
  715.                         { 0 }
  716.                 };
  717.                 config.sDescription = _HELP("Operate on a GameToken");
  718.                 config.pInputPorts = in_config;
  719.                 config.pOutputPorts = out_config;
  720.                 config.nFlags |= EFLN_AISEQUENCE_SUPPORTED;
  721.                 config.SetCategory(EFLN_APPROVED);
  722.         }
  723.  
  724.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  725.         {
  726.                 switch (event)
  727.                 {
  728.                 case eFE_Initialize:
  729.                         m_pCachedToken = 0;
  730.                         break;
  731.                 case eFE_Activate:
  732.                         {
  733.                                 if (IsPortActive(pActInfo, 1))
  734.                                 {
  735.                                         CacheToken(pActInfo);
  736.                                 }
  737.                                 if (IsPortActive(pActInfo, 0))
  738.                                 {
  739.                                         if (m_pCachedToken == NULL)
  740.                                                 CacheToken(pActInfo);
  741.  
  742.                                         if (m_pCachedToken != NULL)
  743.                                         {
  744.                                                 TFlowInputData value;
  745.                                                 m_pCachedToken->GetValue(value);
  746.                                                 TFlowInputData operand;
  747.                                                 operand.Set(GetPortString(pActInfo, 4));
  748.  
  749.                                                 EOperation op = static_cast<EOperation>(GetPortInt(pActInfo, 2));
  750.                                                 EType type = static_cast<EType>(GetPortInt(pActInfo, 3));
  751.                                                 switch (type)
  752.                                                 {
  753.                                                 case ET_BOOL:
  754.                                                         { Helper<bool> h(value, operand); DoOp(op, h); if (h.m_ok) m_pCachedToken->SetValue(TFlowInputData(h.m_value)); }   break;
  755.                                                 case ET_INT:
  756.                                                         { Helper<int> h(value, operand); DoOp(op, h); if (h.m_ok) m_pCachedToken->SetValue(TFlowInputData(h.m_value)); }    break;
  757.                                                 case ET_FLOAT:
  758.                                                         { Helper<float> h(value, operand); DoOp(op, h); if (h.m_ok) m_pCachedToken->SetValue(TFlowInputData(h.m_value)); }  break;
  759.                                                 case ET_VEC3:
  760.                                                         { Helper<Vec3> h(value, operand); DoOp(op, h); if (h.m_ok) m_pCachedToken->SetValue(TFlowInputData(h.m_value)); }   break;
  761.                                                 case ET_STRING:
  762.                                                         { Helper<string> h(value, operand); DoOp(op, h); if (h.m_ok) m_pCachedToken->SetValue(TFlowInputData(h.m_value)); } break;
  763.                                                 }
  764.                                                 m_pCachedToken->GetValue(value);
  765.                                                 ActivateOutput(pActInfo, 0, value);
  766.                                         }
  767.                                 }
  768.                         }
  769.                         break;
  770.                 }
  771.         }
  772.  
  773.         virtual void GetMemoryUsage(ICrySizer* s) const
  774.         {
  775.                 s->Add(*this);
  776.         }
  777.  
  778. private:
  779.         void CacheToken(SActivationInfo* pActInfo, bool bForceCreate = bForceCreateDefault)
  780.         {
  781.                 string name = GetPortString(pActInfo, 1);
  782.                 m_pCachedToken = GetGameToken(pActInfo, name, bForceCreate);
  783.         }
  784.  
  785. private:
  786.         IGameToken* m_pCachedToken;
  787. };
  788.  
  789. //////////////////////////////////////////////////////////////////////////
  790.  
  791. class CFlowNodeGameTokensLevelToLevelStore : public CFlowBaseNode<eNCT_Singleton>
  792. {
  793.         enum
  794.         {
  795.                 INP_TRIGGER = 0,
  796.                 INP_TOKEN1,
  797.                 INP_TOKEN2,
  798.                 INP_TOKEN3,
  799.                 INP_TOKEN4,
  800.                 INP_TOKEN5,
  801.                 INP_TOKEN6,
  802.                 INP_TOKEN7,
  803.                 INP_TOKEN8,
  804.                 INP_TOKEN9,
  805.                 INP_TOKEN10
  806.         };
  807.  
  808. public:
  809.         CFlowNodeGameTokensLevelToLevelStore(SActivationInfo* pActInfo)
  810.         {
  811.         }
  812.  
  813.         virtual void GetConfiguration(SFlowNodeConfig& config)
  814.         {
  815.                 static const SInputPortConfig inputs[] = {
  816.                         InputPortConfig_Void("Trigger",              _HELP("When activated, the values of the specified gametokens will be internally stored so that they can be restored in next level")),
  817.                         InputPortConfig<string>("gametoken_Token1",  _HELP("GameToken to be stored"),                                                                                                      _HELP("Token1")),
  818.                         InputPortConfig<string>("gametoken_Token2",  _HELP("GameToken to be stored"),                                                                                                      _HELP("Token2")),
  819.                         InputPortConfig<string>("gametoken_Token3",  _HELP("GameToken to be stored"),                                                                                                      _HELP("Token3")),
  820.                         InputPortConfig<string>("gametoken_Token4",  _HELP("GameToken to be stored"),                                                                                                      _HELP("Token4")),
  821.                         InputPortConfig<string>("gametoken_Token5",  _HELP("GameToken to be stored"),                                                                                                      _HELP("Token5")),
  822.                         InputPortConfig<string>("gametoken_Token6",  _HELP("GameToken to be stored"),                                                                                                      _HELP("Token6")),
  823.                         InputPortConfig<string>("gametoken_Token7",  _HELP("GameToken to be stored"),                                                                                                      _HELP("Token7")),
  824.                         InputPortConfig<string>("gametoken_Token8",  _HELP("GameToken to be stored"),                                                                                                      _HELP("Token8")),
  825.                         InputPortConfig<string>("gametoken_Token9",  _HELP("GameToken to be stored"),                                                                                                      _HELP("Token9")),
  826.                         InputPortConfig<string>("gametoken_Token10", _HELP("GameToken to be stored"),                                                                                                      _HELP("Token10")),
  827.                         { 0 }
  828.                 };
  829.                 config.pInputPorts = inputs;
  830.                 config.sDescription = _HELP("When triggered, the value of all specified gametokens will be internally stored. Those values can be restored by using the 'restore' flow node in next level");
  831.                 config.SetCategory(EFLN_ADVANCED);
  832.         }
  833.  
  834.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  835.         {
  836.                 switch (event)
  837.                 {
  838.                 case eFE_Activate:
  839.                         {
  840.                                 if (IsPortActive(pActInfo, INP_TRIGGER))
  841.                                 {
  842.                                         std::vector<const char*> gameTokensList;
  843.                                         for (uint32 i = INP_TOKEN1; i <= INP_TOKEN10; ++i)
  844.                                         {
  845.                                                 const string& gameTokenName = GetPortString(pActInfo, i);
  846.                                                 if (!gameTokenName.empty())
  847.                                                         gameTokensList.push_back(gameTokenName.c_str());
  848.                                         }
  849.                                         const char** ppGameTokensList = &(gameTokensList[0]);
  850.                                         GetIGameTokenSystem()->SerializeSaveLevelToLevel(ppGameTokensList, (uint32)gameTokensList.size());
  851.                                 }
  852.                                 break;
  853.                         }
  854.                 }
  855.         }
  856.  
  857.         virtual void GetMemoryUsage(ICrySizer* s) const
  858.         {
  859.                 s->Add(*this);
  860.         }
  861. };
  862.  
  863. //////////////////////////////////////////////////////////////////////////
  864.  
  865. class CFlowNodeGameTokensLevelToLevelRestore : public CFlowBaseNode<eNCT_Singleton>
  866. {
  867.         enum
  868.         {
  869.                 INP_TRIGGER = 0,
  870.         };
  871.  
  872. public:
  873.         CFlowNodeGameTokensLevelToLevelRestore(SActivationInfo* pActInfo)
  874.         {
  875.         }
  876.  
  877.         virtual void GetConfiguration(SFlowNodeConfig& config)
  878.         {
  879.                 static const SInputPortConfig inputs[] = {
  880.                         InputPortConfig_Void("Trigger", _HELP("When activated, the gametokens previously saved with a 'store' flownode (suposedly at the end of the previous level) will recover their stored value")),
  881.                         { 0 }
  882.                 };
  883.                 config.pInputPorts = inputs;
  884.                 config.sDescription = _HELP("When 'Trigger' is activated, the gametokens previously saved with a 'store' flownode (supposedly at the end of the previous level) will recover their stored value");
  885.                 config.SetCategory(EFLN_ADVANCED);
  886.         }
  887.  
  888.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  889.         {
  890.                 switch (event)
  891.                 {
  892.                 case eFE_Activate:
  893.                         {
  894.                                 if (IsPortActive(pActInfo, INP_TRIGGER))
  895.                                 {
  896.                                         GetIGameTokenSystem()->SerializeReadLevelToLevel();
  897.                                 }
  898.                                 break;
  899.                         }
  900.                 }
  901.         }
  902.  
  903.         virtual void GetMemoryUsage(ICrySizer* s) const
  904.         {
  905.                 s->Add(*this);
  906.         }
  907. };
  908.  
  909. REGISTER_FLOW_NODE("Mission:GameTokenModify", CModifyGameTokenFlowNode);
  910. REGISTER_FLOW_NODE("Mission:GameTokenSet", CSetGameTokenFlowNode);
  911. REGISTER_FLOW_NODE("Mission:GameTokenGet", CGetGameTokenFlowNode);
  912. REGISTER_FLOW_NODE("Mission:GameTokenCheck", CCheckGameTokenFlowNode);
  913. REGISTER_FLOW_NODE("Mission:GameTokenCheckMulti", CGameTokenCheckMultiFlowNode);
  914. REGISTER_FLOW_NODE("Mission:GameToken", CGameTokenFlowNode);
  915. REGISTER_FLOW_NODE("Mission:GameTokensLevelToLevelStore", CFlowNodeGameTokensLevelToLevelStore);
  916. REGISTER_FLOW_NODE("Mission:GameTokensLevelToLevelRestore", CFlowNodeGameTokensLevelToLevelRestore);
  917.  
downloadGameTokenNode.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