BVB Source Codes

CRYENGINE Show FlowGameNodes.cpp Source code

Return Download CRYENGINE: download FlowGameNodes.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. #include "CryActionCVars.h"
  6. #include "IActorSystem.h"
  7. #include "GameObjects/GameObject.h"
  8. #include "IGameRulesSystem.h"
  9. #include "ILevelSystem.h"
  10.  
  11. #include <CryFlowGraph/IFlowBaseNode.h>
  12.  
  13. inline IActor* GetAIActor(IFlowNode::SActivationInfo* pActInfo)
  14. {
  15.         if (!pActInfo->pEntity)
  16.                 return 0;
  17.         return CCryAction::GetCryAction()->GetIActorSystem()->GetActor(pActInfo->pEntity->GetId());
  18. }
  19.  
  20. class CFlowPlayer : public CFlowBaseNode<eNCT_Singleton>
  21. {
  22. private:
  23.         enum EInputPort
  24.         {
  25.                 eInputPort_Update = 0,
  26.         };
  27.  
  28.         enum EOuputPort
  29.         {
  30.                 eOutputPort_LocalPlayerId = 0,
  31.         };
  32.  
  33. public:
  34.         CFlowPlayer(SActivationInfo* pActInfo)
  35.         {
  36.         }
  37.  
  38.         virtual void GetConfiguration(SFlowNodeConfig& config)
  39.         {
  40.                 static const SInputPortConfig inputs[] = {
  41.                         InputPortConfig_Void("update", _HELP("Retriggers the entity id. Required for multiplayer")),
  42.                         { 0 }
  43.                 };
  44.                 static const SOutputPortConfig outputs[] = {
  45.                         OutputPortConfig<EntityId>("entityId", _HELP("Player entity id")),
  46.                         { 0 }
  47.                 };
  48.                 config.pInputPorts = inputs;
  49.                 config.pOutputPorts = outputs;
  50.                 config.sDescription = _HELP("Outputs the local players entity id - NOT USABLE FOR MULTIPLAYER WITHOUT UPDATING BY HAND AFTER GAMESTART");
  51.                 config.SetCategory(EFLN_APPROVED);
  52.         }
  53.  
  54.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  55.         {
  56.                 switch (event)
  57.                 {
  58.                 case eFE_Initialize:
  59.                         {
  60.                                 bool done = UpdateEntityIdOutput(pActInfo);
  61.                                 if (!done)
  62.                                         pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, true);
  63.                                 break;
  64.                         }
  65.  
  66.                 case eFE_Activate:
  67.                         UpdateEntityIdOutput(pActInfo);
  68.                         break;
  69.  
  70.                 case eFE_Update:
  71.                         pActInfo->pGraph->SetRegularlyUpdated(pActInfo->myID, false);
  72.                         UpdateEntityIdOutput(pActInfo);
  73.                         break;
  74.                 }
  75.         }
  76.  
  77.         bool UpdateEntityIdOutput(SActivationInfo* pActInfo)
  78.         {
  79.                 EntityId playerId = CCryAction::GetCryAction()->GetClientEntityId();
  80.  
  81.                 if (playerId != 0)
  82.                 {
  83.                         ActivateOutput(pActInfo, eOutputPort_LocalPlayerId, playerId);
  84.                         return true;
  85.                 }
  86.                 else
  87.                 {
  88.                         return false;
  89.                 }
  90.         }
  91.  
  92.         virtual void GetMemoryUsage(ICrySizer* s) const
  93.         {
  94.                 s->Add(*this);
  95.         }
  96. };
  97.  
  98. //////////////////////////////////////////////////////////////////////////
  99.  
  100. void SendFlowHitToEntity(EntityId targetId, EntityId shooterId, int damage, const Vec3& pos)
  101. {
  102.         if (IEntity* pGameRules = CCryAction::GetCryAction()->GetIGameRulesSystem()->GetCurrentGameRulesEntity())
  103.         {
  104.                 if (IScriptTable* pGameRulesScript = pGameRules->GetScriptTable())
  105.                 {
  106.                         IScriptSystem* pSS = pGameRulesScript->GetScriptSystem();
  107.                         if (pGameRulesScript->GetValueType("CreateHit") == svtFunction &&
  108.                             pSS->BeginCall(pGameRulesScript, "CreateHit"))
  109.                         {
  110.                                 pSS->PushFuncParam(pGameRulesScript);
  111.                                 pSS->PushFuncParam(ScriptHandle(targetId));
  112.                                 pSS->PushFuncParam(ScriptHandle(shooterId));
  113.                                 pSS->PushFuncParam(ScriptHandle(0)); // weapon
  114.                                 pSS->PushFuncParam(damage);
  115.                                 pSS->PushFuncParam(0);        // radius
  116.                                 pSS->PushFuncParam("");       // material
  117.                                 pSS->PushFuncParam(0);        // partID
  118.                                 pSS->PushFuncParam("normal"); // type
  119.                                 pSS->PushFuncParam(pos);
  120.                                 pSS->PushFuncParam(FORWARD_DIRECTION); // dir
  121.                                 pSS->PushFuncParam(FORWARD_DIRECTION); // normal
  122.                                 pSS->EndCall();
  123.                         }
  124.                 }
  125.         }
  126. }
  127. //////////////////////////////////////////////////////////////////////////
  128.  
  129. class CFlowDamageActor : public CFlowBaseNode<eNCT_Singleton>
  130. {
  131.         enum
  132.         {
  133.                 INP_TRIGGER = 0,
  134.                 INP_DAMAGE,
  135.                 INP_RELATIVEDAMAGE,
  136.                 INP_POSITION
  137.         };
  138.  
  139. public:
  140.         CFlowDamageActor(SActivationInfo* pActInfo)
  141.         {
  142.         }
  143.  
  144.         virtual void GetConfiguration(SFlowNodeConfig& config)
  145.         {
  146.                 static const SInputPortConfig inputs[] = {
  147.                         InputPortConfig_Void("Trigger",        _HELP("Trigger this port to actually damage the actor")),
  148.                         InputPortConfig<int>("damage",         0,                                                       _HELP("Amount of damage to exert when [Trigger] is activated"),                                                                           _HELP("Damage")),
  149.                         InputPortConfig<int>("damageRelative", 0,                                                       _HELP("Amount of damage to exert when [Trigger] is activated. Is relative to the maximun health of the actor. (100 = full max damage)"),  _HELP("DamageRelative")),
  150.                         InputPortConfig<Vec3>("Position",      Vec3(ZERO),                                              _HELP("Position of damage")),
  151.                         { 0 }
  152.                 };
  153.                 config.pInputPorts = inputs;
  154.                 config.nFlags |= EFLN_TARGET_ENTITY;
  155.                 config.sDescription = _HELP("Damages attached entity by [Damage] when [Trigger] is activated");
  156.                 config.SetCategory(EFLN_APPROVED);
  157.         }
  158.  
  159.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  160.         {
  161.                 switch (event)
  162.                 {
  163.                 case eFE_Activate:
  164.                         if (IsPortActive(pActInfo, INP_TRIGGER))
  165.                         {
  166.                                 IActor* pActor = GetAIActor(pActInfo);
  167.                                 if (pActor)
  168.                                 {
  169.                                         int damage = GetPortInt(pActInfo, INP_DAMAGE);
  170.                                         if (damage == 0)
  171.                                                 damage = (GetPortInt(pActInfo, INP_RELATIVEDAMAGE) * int(pActor->GetMaxHealth())) / 100;
  172.  
  173.                                         SendFlowHitToEntity(pActor->GetEntityId(), pActor->GetEntityId(), damage, GetPortVec3(pActInfo, INP_POSITION));
  174.                                 }
  175.                         }
  176.                         break;
  177.                 }
  178.         }
  179.  
  180.         virtual void GetMemoryUsage(ICrySizer* s) const
  181.         {
  182.                 s->Add(*this);
  183.         }
  184. };
  185.  
  186. class CFlowDamageEntity : public CFlowBaseNode<eNCT_Singleton>
  187. {
  188.         enum
  189.         {
  190.                 INP_TRIGGER = 0,
  191.                 INP_DAMAGE,
  192.                 INP_RELATIVEDAMAGE,
  193.                 INP_POSITION
  194.         };
  195.  
  196. public:
  197.         CFlowDamageEntity(SActivationInfo* pActInfo)
  198.         {
  199.         }
  200.  
  201.         virtual void GetConfiguration(SFlowNodeConfig& config)
  202.         {
  203.                 static const SInputPortConfig inputs[] = {
  204.                         InputPortConfig_Void("Trigger",        _HELP("Trigger this port to actually damage the actor")),
  205.                         InputPortConfig<int>("damage",         0,                                                       _HELP("Amount of damage to exert when [Trigger] is activated"),                                                                                                                                                             _HELP("Damage")),
  206.                         InputPortConfig<int>("damageRelative", 0,                                                       _HELP("Amount of damage to exert when [Trigger] is activated. Is relative to the maximun health of the entity. (100 = full max damage). /nwarning: This will only works for entities with a GetMaxHealth() lua function"),  _HELP("DamageRelative")),
  207.                         InputPortConfig<Vec3>("Position",      Vec3(ZERO),                                              _HELP("Position of damage")),
  208.                         { 0 }
  209.                 };
  210.                 config.pInputPorts = inputs;
  211.                 config.nFlags |= EFLN_TARGET_ENTITY;
  212.                 config.sDescription = _HELP("Damages attached entity by [Damage] when [Trigger] is activated");
  213.                 config.SetCategory(EFLN_APPROVED);
  214.         }
  215.  
  216.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  217.         {
  218.                 switch (event)
  219.                 {
  220.                 case eFE_Activate:
  221.                         if (IsPortActive(pActInfo, INP_TRIGGER))
  222.                         {
  223.                                 IEntity* pEntity = pActInfo->pEntity;
  224.                                 if (pEntity)
  225.                                 {
  226.                                         int damage = GetPortInt(pActInfo, INP_DAMAGE);
  227.                                         if (damage == 0)
  228.                                         {
  229.                                                 int damageRelative = GetPortInt(pActInfo, INP_RELATIVEDAMAGE);
  230.                                                 if (IScriptTable* pScriptTable = pEntity->GetScriptTable())
  231.                                                 {
  232.                                                         IScriptSystem* pSS = pScriptTable->GetScriptSystem();
  233.                                                         if (pScriptTable->GetValueType("GetMaxHealth") == svtFunction && pSS->BeginCall(pScriptTable, "GetMaxHealth"))
  234.                                                         {
  235.                                                                 pSS->PushFuncParam(pScriptTable);
  236.                                                                 ScriptAnyValue result;
  237.                                                                 if (pSS->EndCallAny(result))
  238.                                                                 {
  239.                                                                         int maxHealth = 0;
  240.                                                                         if (result.CopyTo(maxHealth))
  241.                                                                         {
  242.                                                                                 damage = (damageRelative * maxHealth) / 100;
  243.                                                                         }
  244.                                                                 }
  245.                                                         }
  246.                                                 }
  247.                                         }
  248.  
  249.                                         SendFlowHitToEntity(pEntity->GetId(), pEntity->GetId(), damage, GetPortVec3(pActInfo, INP_POSITION));
  250.                                 }
  251.                         }
  252.                         break;
  253.                 }
  254.         }
  255.  
  256.         virtual void GetMemoryUsage(ICrySizer* s) const
  257.         {
  258.                 s->Add(*this);
  259.         }
  260. };
  261.  
  262. class CFlowActorGrabObject : public CFlowBaseNode<eNCT_Singleton>
  263. {
  264. public:
  265.         CFlowActorGrabObject(SActivationInfo* pActInfo)
  266.         {
  267.         }
  268.  
  269.         virtual void GetConfiguration(SFlowNodeConfig& config)
  270.         {
  271.                 static const SInputPortConfig inputs[] = {
  272.                         InputPortConfig<EntityId>("objectId", _HELP("Entity to grab")),
  273.                         InputPortConfig_Void("grab",          _HELP("Pulse this to grab object.")),
  274.                         InputPortConfig_Void("drop",          _HELP("Pulse this to drop currently grabbed object.")),
  275.                         InputPortConfig<bool>("throw",        _HELP("If true, object is thrown forward.")),
  276.                         { 0 }
  277.                 };
  278.                 static const SOutputPortConfig outputs[] = {
  279.                         OutputPortConfig<bool>("success",          _HELP("true if object was grabbed/dropped successfully")),
  280.                         OutputPortConfig<EntityId>("grabbedObjId", _HELP("Currently grabbed object, or 0")),
  281.                         { 0 }
  282.                 };
  283.                 config.pInputPorts = inputs;
  284.                 config.pOutputPorts = outputs;
  285.                 config.nFlags |= EFLN_TARGET_ENTITY;
  286.                 config.sDescription = _HELP("Target entity will try to grab the input object, respectively drop/throw its currently grabbed object.");
  287.                 config.SetCategory(EFLN_APPROVED);
  288.         }
  289.  
  290.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  291.         {
  292.                 switch (event)
  293.                 {
  294.                 case eFE_Activate:
  295.                         {
  296.                                 IActor* pActor = GetAIActor(pActInfo);
  297.                                 if (!pActor)
  298.                                         break;
  299.  
  300.                                 IEntity* pEnt = pActor->GetEntity();
  301.                                 if (!pEnt)
  302.                                         break;
  303.  
  304.                                 HSCRIPTFUNCTION func = 0;
  305.                                 int ret = 0;
  306.                                 IScriptTable* pTable = pEnt->GetScriptTable();
  307.                                 if (!pTable)
  308.                                         break;
  309.  
  310.                                 if (IsPortActive(pActInfo, 1) && pTable->GetValue("GrabObject", func))
  311.                                 {
  312.                                         IEntity* pObj = gEnv->pEntitySystem->GetEntity(GetPortEntityId(pActInfo, 0));
  313.                                         if (pObj)
  314.                                         {
  315.                                                 IScriptTable* pObjTable = pObj->GetScriptTable();
  316.                                                 Script::CallReturn(gEnv->pScriptSystem, func, pTable, pObjTable, ret);
  317.                                         }
  318.                                         ActivateOutput(pActInfo, 0, ret);
  319.                                 }
  320.                                 else if (IsPortActive(pActInfo, 2) && pTable->GetValue("DropObject", func))
  321.                                 {
  322.                                         bool bThrow = GetPortBool(pActInfo, 3);
  323.                                         Script::CallReturn(gEnv->pScriptSystem, func, pTable, bThrow, ret);
  324.                                         ActivateOutput(pActInfo, 0, ret);
  325.                                 }
  326.  
  327.                                 if (pTable->GetValue("GetGrabbedObject", func))
  328.                                 {
  329.                                         ScriptHandle sH(0);
  330.                                         Script::CallReturn(gEnv->pScriptSystem, func, pTable, sH);
  331.                                         ActivateOutput(pActInfo, 1, EntityId(sH.n));
  332.                                 }
  333.  
  334.                                 if (func)
  335.                                         gEnv->pScriptSystem->ReleaseFunc(func);
  336.  
  337.                                 break;
  338.                         }
  339.                 }
  340.         }
  341.  
  342.         virtual void GetMemoryUsage(ICrySizer* s) const
  343.         {
  344.                 s->Add(*this);
  345.         }
  346. };
  347.  
  348. class CFlowActorGetHealth : public CFlowBaseNode<eNCT_Singleton>
  349. {
  350. public:
  351.         CFlowActorGetHealth(SActivationInfo* pActInfo)
  352.         {
  353.         }
  354.  
  355.         virtual void GetConfiguration(SFlowNodeConfig& config)
  356.         {
  357.                 static const SInputPortConfig inputs[] = {
  358.                         InputPortConfig_Void("Trigger", _HELP("Trigger this port to get the current health")),
  359.                         { 0 }
  360.                 };
  361.                 static const SOutputPortConfig outputs[] = {
  362.                         OutputPortConfig<int>("Health", _HELP("Current health of entity")),
  363.                         { 0 }
  364.                 };
  365.                 config.pInputPorts = inputs;
  366.                 config.pOutputPorts = outputs;
  367.                 config.nFlags |= EFLN_TARGET_ENTITY;
  368.                 config.sDescription = _HELP("Get health of an entity (actor)");
  369.                 config.SetCategory(EFLN_APPROVED);
  370.         }
  371.  
  372.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  373.         {
  374.                 switch (event)
  375.                 {
  376.                 case eFE_Activate:
  377.                         if (IsPortActive(pActInfo, 0))
  378.                         {
  379.                                 IActor* pActor = GetAIActor(pActInfo);
  380.                                 if (pActor)
  381.                                 {
  382.                                         ActivateOutput(pActInfo, 0, pActor->GetHealth());
  383.                                 }
  384.                                 else
  385.                                 {
  386.                                         GameWarning("CFlowActorGetHealth - No Entity or Entity not an Actor!");
  387.                                 }
  388.                         }
  389.                 }
  390.         }
  391.  
  392.         virtual void GetMemoryUsage(ICrySizer* s) const
  393.         {
  394.                 s->Add(*this);
  395.         }
  396. };
  397.  
  398. class CFlowActorSetHealth : public CFlowBaseNode<eNCT_Singleton>
  399. {
  400. public:
  401.         CFlowActorSetHealth(SActivationInfo* pActInfo)
  402.         {
  403.         }
  404.  
  405.         virtual void GetConfiguration(SFlowNodeConfig& config)
  406.         {
  407.                 static const SInputPortConfig inputs[] = {
  408.                         InputPortConfig_Void("Trigger", _HELP("Trigger this port to set health")),
  409.                         InputPortConfig<float>("Value", _HELP("Health value to be set on entity when Trigger is activated")),
  410.                         { 0 }
  411.                 };
  412.                 static const SOutputPortConfig outputs[] = {
  413.                         OutputPortConfig<float>("Health", _HELP("Current health of entity (activated when Trigger is activated)")),
  414.                         { 0 }
  415.                 };
  416.                 config.pInputPorts = inputs;
  417.                 config.pOutputPorts = outputs;
  418.                 config.nFlags |= EFLN_TARGET_ENTITY;
  419.                 config.sDescription = _HELP("Set health of an entity (actor)");
  420.                 config.SetCategory(EFLN_APPROVED);
  421.         }
  422.  
  423.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  424.         {
  425.                 switch (event)
  426.                 {
  427.                 case eFE_Activate:
  428.                         if (IsPortActive(pActInfo, 0))
  429.                         {
  430.                                 IActor* pActor = GetAIActor(pActInfo);
  431.                                 if (pActor)
  432.                                 {
  433.                                         if (!pActor->IsDead())
  434.                                         {
  435.                                                 pActor->SetHealth(GetPortFloat(pActInfo, 1));
  436.                                                 ActivateOutput(pActInfo, 0, pActor->GetHealth()); // use pActor->GetHealth (might have been clamped to maxhealth]
  437.                                         }
  438.                                 }
  439.                                 else
  440.                                 {
  441.                                         GameWarning("CFlowActorSetHealth - No Entity or Entity not an actor!");
  442.                                 }
  443.                         }
  444.                 }
  445.         }
  446.  
  447.         virtual void GetMemoryUsage(ICrySizer* s) const
  448.         {
  449.                 s->Add(*this);
  450.         }
  451. };
  452.  
  453. class CFlowActorCheckHealth : public CFlowBaseNode<eNCT_Singleton>
  454. {
  455. public:
  456.         CFlowActorCheckHealth(SActivationInfo* pActInfo)
  457.         {
  458.         }
  459.  
  460.         virtual void GetConfiguration(SFlowNodeConfig& config)
  461.         {
  462.                 static const SInputPortConfig inputs[] = {
  463.                         InputPortConfig_Void("Trigger",     _HELP("Trigger this port to check health")),
  464.                         InputPortConfig<float>("MinHealth", 0.0f,                                       _HELP("Lower limit of range")),
  465.                         InputPortConfig<float>("MaxHealth", 100.0f,                                     _HELP("Upper limit of range")),
  466.                         { 0 }
  467.                 };
  468.                 static const SOutputPortConfig outputs[] = {
  469.                         OutputPortConfig<bool>("InRange", _HELP("True if Health is in range, False otherwise")),
  470.                         { 0 }
  471.                 };
  472.                 config.pInputPorts = inputs;
  473.                 config.pOutputPorts = outputs;
  474.                 config.nFlags |= EFLN_TARGET_ENTITY;
  475.                 config.sDescription = _HELP("Check if health of entity (actor) is in range [MinHealth, MaxHealth]");
  476.                 config.SetCategory(EFLN_APPROVED);
  477.         }
  478.  
  479.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  480.         {
  481.                 switch (event)
  482.                 {
  483.                 case eFE_Activate:
  484.                         if (IsPortActive(pActInfo, 0))
  485.                         {
  486.                                 IActor* pActor = GetAIActor(pActInfo);
  487.                                 if (pActor)
  488.                                 {
  489.                                         float health = pActor->GetHealth();
  490.                                         float minH = GetPortFloat(pActInfo, 1);
  491.                                         float maxH = GetPortFloat(pActInfo, 2);
  492.                                         ActivateOutput(pActInfo, 0, minH <= health && health <= maxH);
  493.                                 }
  494.                                 else
  495.                                 {
  496.                                         CryLogAlways("CFlowActorCheckHealth - No Entity or Entity not an Actor!");
  497.                                 }
  498.                         }
  499.                 }
  500.         }
  501.  
  502.         virtual void GetMemoryUsage(ICrySizer* s) const
  503.         {
  504.                 s->Add(*this);
  505.         }
  506. };
  507.  
  508. class CFlowGameObjectEvent : public CFlowBaseNode<eNCT_Singleton>
  509. {
  510. public:
  511.         CFlowGameObjectEvent(SActivationInfo* pActInfo)
  512.         {
  513.         }
  514.  
  515.         void GetConfiguration(SFlowNodeConfig& config)
  516.         {
  517.                 static const SInputPortConfig in_ports[] =
  518.                 {
  519.                         InputPortConfig_Void("Trigger",       _HELP("Trigger this port to send the event")),
  520.                         InputPortConfig<string>("EventName",  _HELP("Name of event to send")),
  521.                         InputPortConfig<string>("EventParam", _HELP("Parameter of the event [event-specific]")),
  522.                         { 0 }
  523.                 };
  524.                 config.nFlags |= EFLN_TARGET_ENTITY;
  525.                 config.pInputPorts = in_ports;
  526.                 config.pOutputPorts = 0;
  527.                 config.sDescription = _HELP("Broadcast a game object event or send to a specific entity. EventParam is an event specific string");
  528.                 config.SetCategory(EFLN_ADVANCED);
  529.         }
  530.  
  531.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  532.         {
  533.                 if (eFE_Activate == event && IsPortActive(pActInfo, 0))
  534.                 {
  535.                         const string& eventName = GetPortString(pActInfo, 1);
  536.                         uint32 eventId = CCryAction::GetCryAction()->GetIGameObjectSystem()->GetEventID(eventName.c_str());
  537.                         SGameObjectEvent evt(eventId, eGOEF_ToAll, IGameObjectSystem::InvalidExtensionID, (void*) (GetPortString(pActInfo, 2).c_str()));
  538.                         if (pActInfo->pEntity == 0)
  539.                         {
  540.                                 // broadcast to all gameobject events
  541.                                 CCryAction::GetCryAction()->GetIGameObjectSystem()->BroadcastEvent(evt);
  542.                         }
  543.                         else
  544.                         {
  545.                                 // send to a specific entity only
  546.                                 if (CGameObject* pGameObject = (CGameObject*)pActInfo->pEntity->GetProxy(ENTITY_PROXY_USER))
  547.                                         pGameObject->SendEvent(evt);
  548.                         }
  549.                 }
  550.         }
  551.  
  552.         virtual void GetMemoryUsage(ICrySizer* s) const
  553.         {
  554.                 s->Add(*this);
  555.         }
  556. };
  557.  
  558. class CFlowGetSupportedGameRulesForMap : public CFlowBaseNode<eNCT_Singleton>
  559. {
  560. public:
  561.         enum EInputs
  562.         {
  563.                 IN_GET,
  564.                 IN_MAPNAME
  565.         };
  566.         enum EOutputs
  567.         {
  568.                 OUT_DONE
  569.         };
  570.  
  571.         CFlowGetSupportedGameRulesForMap(SActivationInfo* pActInfo)
  572.         {
  573.         }
  574.  
  575.         virtual void GetConfiguration(SFlowNodeConfig& config)
  576.         {
  577.                 static const SInputPortConfig inputs[] = {
  578.                         InputPortConfig_Void("Get",        _HELP("Fetch supported gamerules")),
  579.                         InputPortConfig<string>("Mapname", _HELP("map name")),
  580.                         { 0 }
  581.                 };
  582.                 static const SOutputPortConfig outputs[] = {
  583.                         OutputPortConfig<string>("GameRules", _HELP("Supported gamerules pipe-separated string")),
  584.                         { 0 }
  585.                 };
  586.                 config.pInputPorts = inputs;
  587.                 config.pOutputPorts = outputs;
  588.                 config.sDescription = _HELP("Get supported gamerules for a map");
  589.                 config.SetCategory(EFLN_APPROVED);
  590.         }
  591.  
  592.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  593.         {
  594.                 switch (event)
  595.                 {
  596.                 case eFE_Activate:
  597.                         if (IsPortActive(pActInfo, 0))
  598.                         {
  599.                                 ILevelInfo* pLevelInfo = NULL;
  600.                                 string mapname = GetPortString(pActInfo, IN_MAPNAME);
  601.  
  602.                                 //If mapname is provided, try and fetch those rules
  603.                                 if (strcmp(mapname, "") != 0)
  604.                                         pLevelInfo = CCryAction::GetCryAction()->GetILevelSystem()->GetLevelInfo(mapname);
  605.  
  606.                                 if (pLevelInfo)
  607.                                 {
  608.                                         ILevelInfo::TStringVec gamerules = pLevelInfo->GetGameRules();
  609.                                         string outString = "";
  610.  
  611.                                         for (int i = 0; i < gamerules.size(); i++)
  612.                                         {
  613.                                                 if (i > 0)
  614.                                                         outString.append("|");
  615.                                                 outString.append(gamerules[i]);
  616.                                         }
  617.                                         ActivateOutput(pActInfo, OUT_DONE, outString);
  618.                                 }
  619.                         }
  620.                 }
  621.         }
  622.  
  623.         virtual void GetMemoryUsage(ICrySizer* s) const
  624.         {
  625.                 s->Add(*this);
  626.         }
  627. };
  628.  
  629. class CFlowGetStateOfEntity : public CFlowBaseNode<eNCT_Singleton>
  630. {
  631. public:
  632.         enum EInputs
  633.         {
  634.                 IN_GET,
  635.                 IN_MAPNAME
  636.         };
  637.         enum EOutputs
  638.         {
  639.                 OUT_STATE
  640.         };
  641.  
  642.         CFlowGetStateOfEntity(SActivationInfo* pActInfo)
  643.         {
  644.         }
  645.  
  646.         virtual void GetConfiguration(SFlowNodeConfig& config)
  647.         {
  648.                 static const SInputPortConfig inputs[] = {
  649.                         InputPortConfig_Void("Get", _HELP("Get state")),
  650.                         { 0 }
  651.                 };
  652.                 static const SOutputPortConfig outputs[] = {
  653.                         OutputPortConfig<string>("State", _HELP("Current state as string")),
  654.                         { 0 }
  655.                 };
  656.                 config.nFlags |= EFLN_TARGET_ENTITY;
  657.                 config.pInputPorts = inputs;
  658.                 config.pOutputPorts = outputs;
  659.                 config.sDescription = _HELP("Get current state of an entity");
  660.                 config.SetCategory(EFLN_APPROVED);
  661.         }
  662.  
  663.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  664.         {
  665.                 switch (event)
  666.                 {
  667.                 case eFE_Activate:
  668.                         if (IsPortActive(pActInfo, 0))
  669.                         {
  670.                                 string state = "invalid entity";
  671.                                 IEntity* ent = pActInfo->pEntity;
  672.                                 if (ent)
  673.                                 {
  674.                                         IEntityScriptComponent* pScriptProxy = (IEntityScriptComponent*)ent->GetProxy(ENTITY_PROXY_SCRIPT);
  675.                                         state = "invalid script";
  676.                                         if (pScriptProxy)
  677.                                                 state = pScriptProxy->GetState();
  678.                                 }
  679.  
  680.                                 ActivateOutput(pActInfo, OUT_STATE, state);
  681.                         }
  682.                 }
  683.         }
  684.  
  685.         virtual void GetMemoryUsage(ICrySizer* s) const
  686.         {
  687.                 s->Add(*this);
  688.         }
  689. };
  690.  
  691. //////////////////////////////////////////////////////////////////////////
  692. class CFlowIsLevelOfType : public CFlowBaseNode<eNCT_Singleton>
  693. {
  694. public:
  695.         enum EInputs
  696.         {
  697.                 IN_CHECK,
  698.                 IN_TYPE
  699.         };
  700.         enum EOutputs
  701.         {
  702.                 OUT_RESULT
  703.         };
  704.  
  705.         CFlowIsLevelOfType(SActivationInfo* pActInfo)
  706.         {
  707.         }
  708.  
  709.         virtual void GetConfiguration(SFlowNodeConfig& config)
  710.         {
  711.                 static const SInputPortConfig inputs[] = {
  712.                         InputPortConfig_Void("Check", _HELP("Check if level is of given type")),
  713.                         InputPortConfig<string>("Type", "", _HELP("Type you want to check against"),0, _UICONFIG("enum_global:level_types")),
  714.                         { 0 }
  715.                 };
  716.                 static const SOutputPortConfig outputs[] = {
  717.                         OutputPortConfig<bool>("Result", _HELP("Result")),
  718.                         { 0 }
  719.                 };
  720.  
  721.                 config.pInputPorts = inputs;
  722.                 config.pOutputPorts = outputs;
  723.                 config.sDescription = _HELP("Check if a level is of given type");
  724.                 config.SetCategory(EFLN_APPROVED);
  725.         }
  726.  
  727.         virtual void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  728.         {
  729.                 switch (event)
  730.                 {
  731.                 case eFE_Activate:
  732.                         if (IsPortActive(pActInfo, 0))
  733.                         {
  734.                                 const string levelType = GetPortString(pActInfo, IN_TYPE);
  735.                                 bool bResult = CCryAction::GetCryAction()->GetILevelSystem()->GetCurrentLevel()->IsOfType(levelType);
  736.  
  737.                                 ActivateOutput(pActInfo, OUT_RESULT, bResult);
  738.                         }
  739.                 }
  740.         }
  741.  
  742.         virtual void GetMemoryUsage(ICrySizer* s) const
  743.         {
  744.                 s->Add(*this);
  745.         }
  746. };
  747.  
  748. REGISTER_FLOW_NODE("Actor:LocalPlayer", CFlowPlayer);
  749. REGISTER_FLOW_NODE("Actor:Damage", CFlowDamageActor);
  750. REGISTER_FLOW_NODE("Entity:Damage", CFlowDamageEntity)
  751. REGISTER_FLOW_NODE("Actor:GrabObject", CFlowActorGrabObject);
  752. REGISTER_FLOW_NODE("Actor:HealthGet", CFlowActorGetHealth);
  753. REGISTER_FLOW_NODE("Actor:HealthSet", CFlowActorSetHealth);
  754. REGISTER_FLOW_NODE("Actor:HealthCheck", CFlowActorCheckHealth);
  755. REGISTER_FLOW_NODE("Game:ObjectEvent", CFlowGameObjectEvent);
  756. REGISTER_FLOW_NODE("Game:GetSupportedGameRulesForMap", CFlowGetSupportedGameRulesForMap);
  757. REGISTER_FLOW_NODE("Game:GetEntityState", CFlowGetStateOfEntity);
  758. REGISTER_FLOW_NODE("Game:IsLevelOfType", CFlowIsLevelOfType);
  759.  
downloadFlowGameNodes.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