BVB Source Codes

CRYENGINE Show FlowInventoryNodes.cpp Source code

Return Download CRYENGINE: download FlowInventoryNodes.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:   FlowInventoryNodes.cpp
  5. //  Version:     v1.00
  6. //  Created:     July 11th 2005 by Julien.
  7. //  Compilers:   Visual Studio.NET 2003
  8. //  Description:
  9. // -------------------------------------------------------------------------
  10. //  History:
  11. //
  12. ////////////////////////////////////////////////////////////////////////////
  13.  
  14. #include "StdAfx.h"
  15. #include "CryAction.h"
  16. #include "IActorSystem.h"
  17. #include "ItemSystem.h"
  18. #include "GameObjects/GameObject.h"
  19. #include "Inventory.h"
  20. #include "IGameRulesSystem.h"
  21. #include "FlowFrameworkBaseNode.h"
  22.  
  23. class CFlowNode_InventoryAddItem : public CFlowFrameworkBaseNode<eNCT_Singleton>
  24. {
  25. public:
  26.         CFlowNode_InventoryAddItem(SActivationInfo* pActInfo)
  27.         {
  28.         }
  29.  
  30.         void GetConfiguration(SFlowNodeConfig& config)
  31.         {
  32.                 static const SInputPortConfig in_ports[] =
  33.                 {
  34.                         InputPortConfig_Void("add",         _HELP("Connect event here to add the item")),
  35.                         InputPortConfig<string>("item",     _HELP("The item to add to the inventory"),   _HELP("Item"),                                                                                _UICONFIG("enum_global_ref:item%s:ItemType")),
  36.                         InputPortConfig<string>("ItemType", "",                                          _HELP("Select from which items to choose"),                                                   0,                                            _UICONFIG("enum_string:All=,Givable=_givable,Selectable=_selectable")),
  37.                         InputPortConfig<bool>("Unique",     true,                                        _HELP("If true, only adds the item if the inventory doesn't already contain such an item")),
  38.                         { 0 }
  39.                 };
  40.  
  41.                 static const SOutputPortConfig out_ports[] =
  42.                 {
  43.                         OutputPortConfig<bool>("out", _HELP("true if the item was actually added, false if the player already had the item")),
  44.                         { 0 }
  45.                 };
  46.  
  47.                 config.sDescription = _HELP("Add an item to inventory.");
  48.                 config.nFlags |= EFLN_TARGET_ENTITY;
  49.                 config.pInputPorts = in_ports;
  50.                 config.pOutputPorts = out_ports;
  51.                 config.SetCategory(EFLN_APPROVED);
  52.         }
  53.  
  54.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  55.         {
  56.                 if (event == eFE_Activate && IsPortActive(pActInfo, 0))
  57.                 {
  58.                         IActor* pActor = GetInputActor(pActInfo);
  59.                         if (!pActor || pActor != gEnv->pGameFramework->GetClientActor())  // to avoid some extra RMIs and object creation. Tho, this causes the node to not work properly if it is used with non players entities. (which was never intended anyway)
  60.                                 return;
  61.  
  62.                         IEntitySystem* pEntSys = gEnv->pEntitySystem;
  63.  
  64.                         IInventory* pInventory = pActor->GetInventory();
  65.                         if (!pInventory)
  66.                                 return;
  67.  
  68.                         const string& itemClass = GetPortString(pActInfo, 1);
  69.                         const char* pItemClass = itemClass.c_str();
  70.                         IEntityClass* pClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(pItemClass);
  71.                         EntityId id = pInventory->GetItemByClass(pClass);
  72.  
  73.                         if (id == 0 || GetPortBool(pActInfo, 3) == false)
  74.                         {
  75.                                 if (gEnv->bServer)
  76.                                 {
  77.                                         gEnv->pGameFramework->GetIItemSystem()->GiveItem(pActor, pItemClass, false, true, true);
  78.                                 }
  79.                                 else
  80.                                 {
  81.                                         // TODO: instant output activation, with delayed effective change in the inventory, it potentially could cause problems in rare situations
  82.                                         pInventory->RMIReqToServer_AddItem(pItemClass);
  83.                                 }
  84.                                 ActivateOutput(pActInfo, 0, true);
  85.                         }
  86.                         else
  87.                         {
  88.                                 // item already in inventory
  89.                                 ActivateOutput(pActInfo, 0, false);
  90.                         }
  91.                 }
  92.                 else if (event == eFE_PrecacheResources)
  93.                 {
  94.                         const string& itemClass = GetPortString(pActInfo, 1);
  95.  
  96.                         if (!itemClass.empty())
  97.                         {
  98.                                 IGameRules* pGameRules = CCryAction::GetCryAction()->GetIGameRulesSystem()->GetCurrentGameRules();
  99.                                 CRY_ASSERT_MESSAGE(pGameRules != NULL, "No game rules active, can not precache resources");
  100.                                 if (pGameRules)
  101.                                 {
  102.                                         pGameRules->PrecacheLevelResource(itemClass.c_str(), eGameResourceType_Item);
  103.                                 }
  104.                         }
  105.                 }
  106.         }
  107.  
  108.         virtual void GetMemoryUsage(ICrySizer* s) const
  109.         {
  110.                 s->Add(*this);
  111.         }
  112. };
  113.  
  114. class CFlowNode_InventoryRemoveItem : public CFlowFrameworkBaseNode<eNCT_Singleton>
  115. {
  116. public:
  117.         CFlowNode_InventoryRemoveItem(SActivationInfo* pActInfo)
  118.         {
  119.         }
  120.  
  121.         enum EInputs
  122.         {
  123.                 eIn_Trigger,
  124.                 eIn_Item,
  125.                 eIn_ItemType,
  126.         };
  127.  
  128.         enum EOutputs
  129.         {
  130.                 eOut_Success,
  131.         };
  132.  
  133.         void GetConfiguration(SFlowNodeConfig& config)
  134.         {
  135.                 static const SInputPortConfig in_ports[] =
  136.                 {
  137.                         InputPortConfig_Void("Remove",      _HELP("Connect event here to remove the item")),
  138.                         InputPortConfig<string>("item",     _HELP("The item to remove from the inventory"), _HELP("Item"),                               _UICONFIG("enum_global_ref:item%s:ItemType")),
  139.                         InputPortConfig<string>("ItemType", "",                                             _HELP("Select from which items to choose"),  0,                                            _UICONFIG("enum_string:All=,Givable=_givable,Selectable=_selectable")),
  140.                         { 0 }
  141.                 };
  142.  
  143.                 static const SOutputPortConfig out_ports[] =
  144.                 {
  145.                         OutputPortConfig<bool>("out", _HELP("true if the item was actually removed, false if the player did not have the item")),
  146.                         { 0 }
  147.                 };
  148.  
  149.                 config.sDescription = _HELP("Remove an item from inventory.");
  150.                 config.nFlags |= EFLN_TARGET_ENTITY;
  151.                 config.pInputPorts = in_ports;
  152.                 config.pOutputPorts = out_ports;
  153.                 config.SetCategory(EFLN_APPROVED);
  154.         }
  155.  
  156.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  157.         {
  158.                 if (event == eFE_Activate && IsPortActive(pActInfo, eIn_Trigger))
  159.                 {
  160.                         IActor* pActor = GetInputActor(pActInfo);
  161.                         if (!pActor || pActor != gEnv->pGameFramework->GetClientActor()) // to avoid some extra RMIs and object creation. Tho, this causes the node to not work properly if it is used with non players entities. (which was never intended anyway)
  162.                         {
  163.                                 return;
  164.                         }
  165.  
  166.                         IInventory* pInventory = pActor->GetInventory();
  167.                         if (!pInventory)
  168.                         {
  169.                                 return;
  170.                         }
  171.  
  172.                         const string& itemClass = GetPortString(pActInfo, eIn_Item);
  173.                         IEntityClass* pClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(itemClass.c_str());
  174.                         EntityId id = pInventory->GetItemByClass(pClass);
  175.  
  176.                         if (id != 0)
  177.                         {
  178.                                 pInventory->RMIReqToServer_RemoveItem(itemClass.c_str());
  179.                                 ActivateOutput(pActInfo, eOut_Success, true);
  180.                         }
  181.                         else
  182.                         {
  183.                                 ActivateOutput(pActInfo, eOut_Success, false);
  184.                         }
  185.                 }
  186.         }
  187.  
  188.         virtual void GetMemoryUsage(ICrySizer* s) const
  189.         {
  190.                 s->Add(*this);
  191.         }
  192. };
  193.  
  194. class CFlowNode_InventoryRemoveAllItems : public CFlowFrameworkBaseNode<eNCT_Singleton>
  195. {
  196. public:
  197.         CFlowNode_InventoryRemoveAllItems(SActivationInfo* pActInfo)
  198.         {
  199.         }
  200.  
  201.         void GetConfiguration(SFlowNodeConfig& config)
  202.         {
  203.                 static const SInputPortConfig in_ports[] =
  204.                 {
  205.                         InputPortConfig_Void("Activate", _HELP("Connect event here to remove all items from inventory")),
  206.                         { 0 }
  207.                 };
  208.  
  209.                 static const SOutputPortConfig out_ports[] =
  210.                 {
  211.                         OutputPortConfig<bool>("Done", _HELP("True when done successfully")),
  212.                         { 0 }
  213.                 };
  214.  
  215.                 config.sDescription = _HELP("When activated, removes all items from inventory.");
  216.                 config.nFlags |= EFLN_TARGET_ENTITY;
  217.                 config.pInputPorts = in_ports;
  218.                 config.pOutputPorts = out_ports;
  219.                 config.SetCategory(EFLN_APPROVED);
  220.         }
  221.  
  222.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  223.         {
  224.                 if (event == eFE_Activate && IsPortActive(pActInfo, 0))
  225.                 {
  226.                         IGameFramework* pGF = gEnv->pGameFramework;
  227.  
  228.                         IActor* pActor = GetInputActor(pActInfo);
  229.                         if (!pActor || pActor != gEnv->pGameFramework->GetClientActor())  // to avoid some extra RMIs and object creation. Tho, this causes the node to not work properly if it is used with non players entities. (which was never intended anyway)
  230.                                 return;
  231.  
  232.                         IInventory* pInventory = pActor->GetInventory();
  233.                         if (!pInventory)
  234.                                 return;
  235.  
  236.                         pInventory->RMIReqToServer_RemoveAllItems();
  237.                         // TODO: instant output activation, with delayed effective change in the inventory, it potentially could cause problems in rare situations
  238.                         ActivateOutput(pActInfo, 0, true);
  239.                 }
  240.         }
  241.  
  242.         virtual void GetMemoryUsage(ICrySizer* s) const
  243.         {
  244.                 s->Add(*this);
  245.         }
  246. };
  247.  
  248. class CFlowNode_InventoryHasItem : public CFlowFrameworkBaseNode<eNCT_Singleton>
  249. {
  250. public:
  251.         CFlowNode_InventoryHasItem(SActivationInfo* pActInfo)
  252.         {
  253.         }
  254.  
  255.         void GetConfiguration(SFlowNodeConfig& config)
  256.         {
  257.                 static const SInputPortConfig in_ports[] =
  258.                 {
  259.                         InputPortConfig_Void("check",       _HELP("Connect event here to check the inventory for the item"), _HELP("Check")),
  260.                         InputPortConfig<string>("item",     _HELP("The item to add to the inventory"),                       _HELP("Item"),                             _UICONFIG("enum_global_ref:item%s:ItemType")),
  261.                         InputPortConfig<string>("ItemType", "",                                                              _HELP("Select from which items to choose"),0,                     _UICONFIG("enum_string:All=,Givable=_givable,Selectable=_selectable")),
  262.                         { 0 }
  263.                 };
  264.  
  265.                 static const SOutputPortConfig out_ports[] =
  266.                 {
  267.                         OutputPortConfig<bool>("out",        _HELP("True if the player has the item, false otherwise"), _HELP("Out")),
  268.                         OutputPortConfig_Void("False",       _HELP("Triggered if player does not have the item")),
  269.                         OutputPortConfig_Void("True",        _HELP("Triggered if player has the item")),
  270.                         OutputPortConfig<EntityId>("ItemId", _HELP("Outputs the item's entity id")),
  271.                         { 0 }
  272.                 };
  273.  
  274.                 config.sDescription = _HELP("Check inventory to see if an item is present.");
  275.                 config.nFlags |= EFLN_TARGET_ENTITY;
  276.                 config.pInputPorts = in_ports;
  277.                 config.pOutputPorts = out_ports;
  278.                 config.SetCategory(EFLN_APPROVED);
  279.         }
  280.  
  281.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  282.         {
  283.                 if (event == eFE_Activate && IsPortActive(pActInfo, 0))
  284.                 {
  285.                         IActor* pActor = GetInputActor(pActInfo);
  286.                         if (!pActor)
  287.                                 return;
  288.  
  289.                         IInventory* pInventory = pActor->GetInventory();
  290.                         if (!pInventory)
  291.                                 return;
  292.  
  293.                         IEntityClass* pClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(GetPortString(pActInfo, 1));
  294.                         EntityId id = pInventory->GetItemByClass(pClass);
  295.  
  296.                         ActivateOutput(pActInfo, 0, id != 0 ? true : false);
  297.                         ActivateOutput(pActInfo, id != 0 ? 2 : 1, true);
  298.                         ActivateOutput(pActInfo, 3, id);
  299.                 }
  300.         }
  301.  
  302.         virtual void GetMemoryUsage(ICrySizer* s) const
  303.         {
  304.                 s->Add(*this);
  305.         }
  306. };
  307.  
  308. class CFlowNode_InventorySelectItem : public CFlowFrameworkBaseNode<eNCT_Singleton>
  309. {
  310. public:
  311.         CFlowNode_InventorySelectItem(SActivationInfo* pActInfo)
  312.         {
  313.         }
  314.  
  315.         void GetConfiguration(SFlowNodeConfig& config)
  316.         {
  317.                 static const SInputPortConfig in_ports[] =
  318.                 {
  319.                         InputPortConfig_Void("Activate", _HELP("Select the item")),
  320.                         InputPortConfig<string>("Item",  _HELP("Item to select, has to be in inventory"),0, _UICONFIG("enum_global:item_selectable")),
  321.                         { 0 }
  322.                 };
  323.  
  324.                 static const SOutputPortConfig out_ports[] =
  325.                 {
  326.                         OutputPortConfig<bool>("Done", _HELP("True when executed, if the item is in the inventory and could be selected")),
  327.                         { 0 }
  328.                 };
  329.  
  330.                 config.sDescription = _HELP("Select an item from within the inventory.");
  331.                 config.nFlags |= EFLN_TARGET_ENTITY;
  332.                 config.pInputPorts = in_ports;
  333.                 config.pOutputPorts = out_ports;
  334.                 config.SetCategory(EFLN_APPROVED);
  335.         }
  336.  
  337.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  338.         {
  339.                 IGameFramework* pGF = gEnv->pGameFramework;
  340.  
  341.                 if (event == eFE_Activate && IsPortActive(pActInfo, 0))
  342.                 {
  343.                         IActor* pActor = GetInputActor(pActInfo);
  344.                         if (!pActor)
  345.                                 return;
  346.  
  347.                         IInventory* pInventory = pActor->GetInventory();
  348.                         if (!pInventory)
  349.                                 return;
  350.  
  351.                         const string& item = GetPortString(pActInfo, 1);
  352.  
  353.                         IEntityClass* pClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(item);
  354.                         if (0 == pInventory->GetItemByClass(pClass))
  355.                         {
  356.                                 ActivateOutput(pActInfo, 0, false);
  357.                         }
  358.                         else
  359.                         {
  360.                                 pGF->GetIItemSystem()->SetActorItem(pActor, item, true);
  361.                                 ActivateOutput(pActInfo, 0, true);
  362.                         }
  363.                 }
  364.         }
  365.  
  366.         virtual void GetMemoryUsage(ICrySizer* s) const
  367.         {
  368.                 s->Add(*this);
  369.         }
  370. };
  371.  
  372. class CFlowNode_InventoryHolsterItem : public CFlowBaseNode<eNCT_Singleton>
  373. {
  374. public:
  375.         CFlowNode_InventoryHolsterItem(SActivationInfo* pActInfo)
  376.         {
  377.         }
  378.  
  379.         void GetConfiguration(SFlowNodeConfig& config)
  380.         {
  381.                 static const SInputPortConfig in_ports[] =
  382.                 {
  383.                         InputPortConfig_Void("Holster",   _HELP("Holster current item")),
  384.                         InputPortConfig_Void("UnHolster", _HELP("Unholster current item")),
  385.                         { 0 }
  386.                 };
  387.  
  388.                 static const SOutputPortConfig out_ports[] =
  389.                 {
  390.                         OutputPortConfig_Void("Done", _HELP("Done")),
  391.                         { 0 }
  392.                 };
  393.  
  394.                 config.pInputPorts = in_ports;
  395.                 config.pOutputPorts = out_ports;
  396.                 config.SetCategory(EFLN_APPROVED);
  397.         }
  398.  
  399.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  400.         {
  401.                 if (event == eFE_Activate)
  402.                 {
  403.                         IGameFramework* pGF = gEnv->pGameFramework;
  404.  
  405.                         IActor* pActor = pGF->GetClientActor();
  406.                         if (!pActor)
  407.                                 return;
  408.                         const bool bHolster = IsPortActive(pActInfo, 0);
  409.                         pActor->HolsterItem(bHolster);
  410.                         ActivateOutput(pActInfo, 0, true);
  411.                 }
  412.         }
  413.  
  414.         virtual void GetMemoryUsage(ICrySizer* s) const
  415.         {
  416.                 s->Add(*this);
  417.         }
  418. };
  419.  
  420. class CFlowNode_InventoryItemSelected : public CFlowFrameworkBaseNode<eNCT_Instanced>, public IItemSystemListener
  421. {
  422.  
  423.         enum
  424.         {
  425.                 INP_ACTIVE = 0,
  426.                 INP_CHECK
  427.         };
  428.  
  429. public:
  430.         CFlowNode_InventoryItemSelected(SActivationInfo* pActInfo) : m_actInfo(*pActInfo)
  431.         {
  432.                 m_pGF = gEnv->pGameFramework;
  433.         }
  434.  
  435.         ~CFlowNode_InventoryItemSelected()
  436.         {
  437.                 IItemSystem* pItemSys = m_pGF->GetIItemSystem();
  438.                 if (pItemSys)
  439.                         pItemSys->UnregisterListener(this);
  440.         }
  441.  
  442.         IFlowNodePtr Clone(SActivationInfo* pActInfo)
  443.         {
  444.                 return new CFlowNode_InventoryItemSelected(pActInfo);
  445.         }
  446.  
  447.         void GetConfiguration(SFlowNodeConfig& config)
  448.         {
  449.                 static const SInputPortConfig in_ports[] =
  450.                 {
  451.                         InputPortConfig<bool>("Active",  true,                                                                             _HELP("Set to active to get notified when a new item was selected")),
  452.                         InputPortConfig_AnyType("Check", _HELP("Trigger to instantly check which item the actor has currently selected")),
  453.                         { 0 }
  454.                 };
  455.  
  456.                 static const SOutputPortConfig out_ports[] =
  457.                 {
  458.                         OutputPortConfig<string>("ItemClass", _HELP("Outputs selected item's class")),
  459.                         OutputPortConfig<string>("ItemName",  _HELP("Outputs selected item's name")),
  460.                         OutputPortConfig<EntityId>("ItemId",  _HELP("Outputs selected item's entity id")),
  461.                         { 0 }
  462.                 };
  463.  
  464.                 config.sDescription = _HELP("Tracks the currently selected item of the actor. Use [Active] to enable.");
  465.                 config.nFlags |= EFLN_TARGET_ENTITY;
  466.                 config.pInputPorts = in_ports;
  467.                 config.pOutputPorts = out_ports;
  468.                 config.SetCategory(EFLN_APPROVED);
  469.         }
  470.  
  471.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  472.         {
  473.                 if (event == eFE_Activate || event == eFE_Initialize)
  474.                 {
  475.                         if (IsPortActive(pActInfo, INP_ACTIVE))
  476.                         {
  477.                                 bool active = GetPortBool(pActInfo, 0);
  478.                                 if (active)
  479.                                         m_pGF->GetIItemSystem()->RegisterListener(this);
  480.                                 else
  481.                                         m_pGF->GetIItemSystem()->UnregisterListener(this);
  482.                         }
  483.                         if (IsPortActive(pActInfo, INP_CHECK))
  484.                         {
  485.                                 IActor* pActor = GetInputActor(pActInfo);
  486.                                 if (pActor)
  487.                                 {
  488.                                         IInventory* pInventory = pActor->GetInventory();
  489.                                         if (pInventory)
  490.                                         {
  491.                                                 IEntity* pEntityItem = gEnv->pEntitySystem->GetEntity(pInventory->GetCurrentItem());
  492.                                                 TriggerOutputs(pActInfo, pEntityItem);
  493.                                         }
  494.                                 }
  495.                         }
  496.                 }
  497.         }
  498.  
  499.         virtual void OnSetActorItem(IActor* pSetActor, IItem* pItem)
  500.         {
  501.                 IActor* pActor = GetInputActor(&m_actInfo);
  502.                 if (!pActor || pActor != pSetActor)
  503.                         return;
  504.  
  505.                 TriggerOutputs(&m_actInfo, pItem ? pItem->GetEntity() : NULL);
  506.         }
  507.  
  508.         virtual void OnDropActorItem(IActor* pActor, IItem* pItem)
  509.         {
  510.         }
  511.  
  512.         virtual void OnSetActorAccessory(IActor* pActor, IItem* pItem)
  513.         {
  514.         }
  515.  
  516.         virtual void OnDropActorAccessory(IActor* pActor, IItem* pItem)
  517.         {
  518.         }
  519.  
  520.         virtual void TriggerOutputs(SActivationInfo* pActInfo, IEntity* pItem)
  521.         {
  522.                 string name;
  523.                 if (pItem)
  524.                 {
  525.                         name = pItem->GetClass()->GetName();
  526.                         ActivateOutput(&m_actInfo, 0, name);
  527.                         name = pItem->GetName();
  528.                         ActivateOutput(&m_actInfo, 1, name);
  529.                         ActivateOutput(&m_actInfo, 2, pItem->GetId());
  530.                 }
  531.                 else
  532.                 {
  533.                         ActivateOutput(&m_actInfo, 0, name);
  534.                         ActivateOutput(&m_actInfo, 1, name);
  535.                         ActivateOutput(&m_actInfo, 2, 0);
  536.                 }
  537.         }
  538.  
  539.         virtual void GetMemoryUsage(ICrySizer* s) const
  540.         {
  541.                 s->Add(*this);
  542.         }
  543.  
  544. protected:
  545.         SActivationInfo m_actInfo;
  546.         IGameFramework* m_pGF;
  547. };
  548.  
  549. class CFlowNode_InventoryRemoveAllAmmo : public CFlowFrameworkBaseNode<eNCT_Singleton>
  550. {
  551. public:
  552.         CFlowNode_InventoryRemoveAllAmmo(SActivationInfo* pActInfo)
  553.         {
  554.         }
  555.  
  556.         void GetConfiguration(SFlowNodeConfig& config)
  557.         {
  558.                 static const SInputPortConfig in_ports[] =
  559.                 {
  560.                         InputPortConfig_Void("Remove",            _HELP("Connect event here to remove all the ammo")),
  561.                         InputPortConfig<bool>("RemoveFromWeapon", false,                                              _HELP("If true, also removes all ammo from all weapons.")),
  562.                         { 0 }
  563.                 };
  564.  
  565.                 static const SOutputPortConfig out_ports[] =
  566.                 {
  567.                         OutputPortConfig<bool>("Out", _HELP("true if the ammo was actually removed, false otherwise")),
  568.                         { 0 }
  569.                 };
  570.  
  571.                 config.sDescription = _HELP("Remove ammo from current weapon and/or all ammo in inventory.");
  572.                 config.nFlags |= EFLN_TARGET_ENTITY;
  573.                 config.pInputPorts = in_ports;
  574.                 config.pOutputPorts = out_ports;
  575.                 config.SetCategory(EFLN_APPROVED);
  576.         }
  577.  
  578.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  579.         {
  580.                 if (event == eFE_Activate && IsPortActive(pActInfo, 0))
  581.                 {
  582.                         IActor* pActor = GetInputActor(pActInfo);
  583.                         if (!pActor)
  584.                                 return;
  585.  
  586.                         IInventory* pInventory = pActor->GetInventory();
  587.  
  588.                         if (pInventory)
  589.                         {
  590.                                 pInventory->ResetAmmo();
  591.  
  592.                                 const bool removeFromWeapons = GetPortBool(pActInfo, 1);
  593.                                 if (removeFromWeapons)
  594.                                 {
  595.                                         IItemSystem* pItemSystem = CCryAction::GetCryAction()->GetIItemSystem();
  596.                                         const size_t numItems = pInventory->GetCount();
  597.                                         for (size_t i = 0; i < numItems; ++i)
  598.                                         {
  599.                                                 const EntityId item = pInventory->GetItem(i);
  600.                                                 if (IItem* pItem = pItemSystem->GetItem(item))
  601.                                                 {
  602.                                                         if (IWeapon* pWeapon = pItem->GetIWeapon())
  603.                                                         {
  604.                                                                 const size_t numFiremodes = pWeapon->GetNumOfFireModes();
  605.                                                                 for (size_t f = 0; f < numFiremodes; ++f)
  606.                                                                 {
  607.                                                                         if (IFireMode* pFireMode = pWeapon->GetFireMode(f))
  608.                                                                         {
  609.                                                                                 if (IEntityClass* pAmmoType = pFireMode->GetAmmoType())
  610.                                                                                 {
  611.                                                                                         pWeapon->SetAmmoCount(pAmmoType, 0);
  612.                                                                                 }
  613.                                                                         }
  614.                                                                 }
  615.                                                         }
  616.                                                 }
  617.                                         }
  618.                                 }
  619.                                 ActivateOutput(pActInfo, 0, true);
  620.                         }
  621.                         else
  622.                                 ActivateOutput(pActInfo, 0, false);
  623.                 }
  624.         }
  625.  
  626.         virtual void GetMemoryUsage(ICrySizer* s) const
  627.         {
  628.                 s->Add(*this);
  629.         }
  630. };
  631.  
  632. class CFlowNode_AddEquipmentPack : public CFlowFrameworkBaseNode<eNCT_Singleton>
  633. {
  634. public:
  635.         enum EInputs
  636.         {
  637.                 EIP_Trigger,
  638.                 EIP_EquipmentPack,
  639.                 EIP_AddToggle,
  640.                 EIP_SelectPrimary
  641.         };
  642.  
  643.         enum EOutputs
  644.         {
  645.                 EOP_Done
  646.         };
  647.  
  648.         CFlowNode_AddEquipmentPack(SActivationInfo* pActInfo)
  649.         {
  650.         }
  651.  
  652.         void GetConfiguration(SFlowNodeConfig& config)
  653.         {
  654.                 static const SInputPortConfig in_ports[] =
  655.                 {
  656.                         InputPortConfig_Void("Trigger",        _HELP("Trigger to give the pack")),
  657.                         InputPortConfig<string>("equip_Pack",  _HELP("Name of the pack")),
  658.                         InputPortConfig<bool>("Add",           false,                             _HELP("Replace/Add selected equipment pack; 0=Replace,1=Add")),
  659.                         InputPortConfig<bool>("SelectPrimary", false,                             _HELP("Select primary weapon by default")),
  660.                         { 0 }
  661.                 };
  662.  
  663.                 static const SOutputPortConfig out_ports[] =
  664.                 {
  665.                         OutputPortConfig_Void("Done", _HELP("Triggered when done.")),
  666.                         { 0 }
  667.                 };
  668.  
  669.                 config.sDescription = _HELP("Add to existing or replace existing equipment pack.");
  670.                 config.nFlags |= EFLN_TARGET_ENTITY;
  671.                 config.pInputPorts = in_ports;
  672.                 config.pOutputPorts = out_ports;
  673.                 config.SetCategory(EFLN_APPROVED);
  674.         }
  675.  
  676.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  677.         {
  678.                 if (event == eFE_Activate && IsPortActive(pActInfo, EIP_Trigger))
  679.                 {
  680.                         IActor* pActor = GetInputActor(pActInfo);
  681.                         if (!pActor)
  682.                                 return;
  683.  
  684.                         IInventory* pInventory = pActor->GetInventory();
  685.                         if (!pInventory)
  686.                                 return;
  687.  
  688.                         const bool& addPack = GetPortBool(pActInfo, EIP_AddToggle);
  689.                         const string& packName = GetPortString(pActInfo, EIP_EquipmentPack);
  690.                         const bool& selectPrimary = GetPortBool(pActInfo, EIP_SelectPrimary);
  691.  
  692.                         if (pActor->IsPlayer())
  693.                                 pInventory->RMIReqToServer_AddEquipmentPack(packName.c_str(), addPack, selectPrimary);
  694.                         else
  695.                         {
  696.                                 if (gEnv->bServer)
  697.                                         CCryAction::GetCryAction()->GetIItemSystem()->GetIEquipmentManager()->GiveEquipmentPack(pActor, packName.c_str(), addPack, selectPrimary);
  698.                         }
  699.  
  700.                         // TODO: instant output activation, with delayed effective change in the inventory, it potentially could cause problems in rare situations
  701.                         ActivateOutput(pActInfo, EOP_Done, true);
  702.                 }
  703.                 else if (event == eFE_PrecacheResources)
  704.                 {
  705.                         const string& packName = GetPortString(pActInfo, 1);
  706.  
  707.                         if (!packName.empty())
  708.                         {
  709.                                 IGameRules* const pGameRules = CCryAction::GetCryAction()->GetIGameRulesSystem()->GetCurrentGameRules();
  710.                                 if (pGameRules)
  711.                                 {
  712.                                         pGameRules->PrecacheLevelResource(packName.c_str(), eGameResourceType_Loadout);
  713.                                 }
  714.                                 else
  715.                                 {
  716.                                         GameWarning("No game rules active, can not precache resources");
  717.                                 }
  718.                         }
  719.                 }
  720.         }
  721.  
  722.         virtual void GetMemoryUsage(ICrySizer* s) const
  723.         {
  724.                 s->Add(*this);
  725.         }
  726. };
  727.  
  728. class CFlowNode_StorePlayerInventory : public CFlowBaseNode<eNCT_Singleton>
  729. {
  730. public:
  731.         CFlowNode_StorePlayerInventory(SActivationInfo* pActInfo)
  732.         {
  733.         }
  734.  
  735.         void GetConfiguration(SFlowNodeConfig& config)
  736.         {
  737.                 static const SInputPortConfig in_ports[] =
  738.                 {
  739.                         InputPortConfig_Void("Trigger", _HELP("Trigger to store Player's Inventory.")),
  740.                         { 0 }
  741.                 };
  742.  
  743.                 static const SOutputPortConfig out_ports[] =
  744.                 {
  745.                         OutputPortConfig_Void("Done", _HELP("Triggered when done.")),
  746.                         { 0 }
  747.                 };
  748.  
  749.                 config.pInputPorts = in_ports;
  750.                 config.pOutputPorts = out_ports;
  751.                 config.SetCategory(EFLN_ADVANCED);
  752.         }
  753.  
  754.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  755.         {
  756.                 if (event == eFE_Activate && IsPortActive(pActInfo, 0))
  757.                 {
  758.                         CItemSystem* pItemSystem = static_cast<CItemSystem*>(CCryAction::GetCryAction()->GetIItemSystem());
  759.                         pItemSystem->SerializePlayerLTLInfo(false);
  760.                         ActivateOutput(pActInfo, 0, true);
  761.                 }
  762.         }
  763.  
  764.         virtual void GetMemoryUsage(ICrySizer* s) const
  765.         {
  766.                 s->Add(*this);
  767.         }
  768. };
  769.  
  770. class CFlowNode_RestorePlayerInventory : public CFlowBaseNode<eNCT_Singleton>
  771. {
  772. public:
  773.         CFlowNode_RestorePlayerInventory(SActivationInfo* pActInfo)
  774.         {
  775.         }
  776.  
  777.         void GetConfiguration(SFlowNodeConfig& config)
  778.         {
  779.                 static const SInputPortConfig in_ports[] =
  780.                 {
  781.                         InputPortConfig_Void("Trigger", _HELP("Trigger to restore Player's Inventory.")),
  782.                         { 0 }
  783.                 };
  784.  
  785.                 static const SOutputPortConfig out_ports[] =
  786.                 {
  787.                         OutputPortConfig_Void("Done", _HELP("Triggered when done.")),
  788.                         { 0 }
  789.                 };
  790.  
  791.                 config.pInputPorts = in_ports;
  792.                 config.pOutputPorts = out_ports;
  793.                 config.SetCategory(EFLN_ADVANCED);
  794.         }
  795.  
  796.         void ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
  797.         {
  798.                 if (event == eFE_Activate && IsPortActive(pActInfo, 0))
  799.                 {
  800.                         CItemSystem* pItemSystem = static_cast<CItemSystem*>(CCryAction::GetCryAction()->GetIItemSystem());
  801.                         pItemSystem->SerializePlayerLTLInfo(true);
  802.                         ActivateOutput(pActInfo, 0, true);
  803.                 }
  804.         }
  805.  
  806.         virtual void GetMemoryUsage(ICrySizer* s) const
  807.         {
  808.                 s->Add(*this);
  809.         }
  810. };
  811.  
  812. REGISTER_FLOW_NODE("Inventory:ItemAdd", CFlowNode_InventoryAddItem);
  813. REGISTER_FLOW_NODE("Inventory:ItemRemove", CFlowNode_InventoryRemoveItem);
  814. REGISTER_FLOW_NODE("Inventory:ItemRemoveAll", CFlowNode_InventoryRemoveAllItems);
  815. REGISTER_FLOW_NODE("Inventory:ItemCheck", CFlowNode_InventoryHasItem);
  816. REGISTER_FLOW_NODE("Inventory:HolsterItem", CFlowNode_InventoryHolsterItem);
  817. REGISTER_FLOW_NODE("Inventory:ItemSelect", CFlowNode_InventorySelectItem);
  818. REGISTER_FLOW_NODE("Inventory:ItemSelected", CFlowNode_InventoryItemSelected);
  819. REGISTER_FLOW_NODE("Inventory:AmmoRemoveAll", CFlowNode_InventoryRemoveAllAmmo);
  820. REGISTER_FLOW_NODE("Inventory:EquipPackAdd", CFlowNode_AddEquipmentPack);
  821. REGISTER_FLOW_NODE("Inventory:PlayerInventoryStore", CFlowNode_StorePlayerInventory);
  822. REGISTER_FLOW_NODE("Inventory:PlayerInventoryRestore", CFlowNode_RestorePlayerInventory);
  823.  
downloadFlowInventoryNodes.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